Upload 3 files

Dockerfile

@@ -1,20 +1,29 @@
-FROM python:3.13.5-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Usar una imagen oficial de Python ligera
+FROM python:3.10-slim
+
+# Instalar g++ y herramientas de compilación para C++
+RUN apt-get update && apt-get install -y \
+    g++ \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Configurar un usuario no root (Requisito de seguridad en Hugging Face Spaces)
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# Establecer el directorio de trabajo
+WORKDIR /app
+
+# Copiar el archivo de requerimientos e instalar dependencias
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copiar el resto del código de la aplicación
+COPY --chown=user . .
+
+# Exponer el puerto de Streamlit
+EXPOSE 8501
+
+# Comando para iniciar la aplicación
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

app.py

@@ -0,0 +1,152 @@
+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")
+
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+with st.sidebar:
+    st.header("Configuracion del Modelo")
+    selected_model = st.selectbox(
+        "Selecciona el modelo de Hugging Face:",
+        [
+            "Qwen/CodeQwen1.5-7B-Chat",
+            "meta-llama/CodeLlama-13b-Instruct-hf",
+            "bigcode/starcoder2-15b"
+        ],
+        index=0
+    )
+    
+    st.markdown("---")
+    st.markdown("### Entorno de Ejecucion")
+    st.code("g++ -O3 -std=c++17", language="bash")
+    
+    if st.button("Limpiar Historial"):
+        st.session_state.messages = []
+        st.rerun()
+
+def get_system_prompt() -> str:
+    return (
+        "You are an expert compiler and AI engineer specializing in migrating Python code to high-performance C++17. "
+        "Your task is to provide direct, efficient, and thread-safe C++17 code. "
+        "Include all necessary headers (<iostream>, <vector>, <memory>, etc.). "
+        "Ensure strict type safety and prevent integer overflows. "
+        "Respond ONLY with the raw C++ code enclosed in ```cpp block. Do not add explanations."
+    )
+
+def extract_cpp_code(response_text: str) -> str:
+    """Extrae el codigo C++ limpiando los bloques de markdown."""
+    if "```cpp" in response_text:
+        code = response_text.split("```cpp")[1].split("```")[0]
+    elif "```c++" in response_text:
+        code = response_text.split("```c++")[1].split("```")[0]
+    elif "```" in response_text:
+        code = response_text.split("```")[1].split("```")[0]
+    else:
+        code = response_text
+    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."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        cpp_file = os.path.join(tmpdir, "optimized.cpp")
+        exe_file = os.path.join(tmpdir, "optimized_bin")
+        
+        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)."
+            
+        except subprocess.CalledProcessError as e:
+            return f"Error de Compilacion:\n{e.stderr}"
+        except subprocess.TimeoutExpired:
+            return "Timeout: La ejecucion excedio 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.")
+
+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"):
+                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
+    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")
+    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..."):
+            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
+                )
+                
+                clean_cpp = extract_cpp_code(response)
+                st.code(clean_cpp, language="cpp")
+                
+                st.markdown("---")
+                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):
+                    st.text(execution_output)
+                    
+                # Guardar en el historial
+                st.session_state.messages.append({
+                    "role": "assistant", 
+                    "content": {
+                        "code": clean_cpp,
+                        "output": execution_output
+                    }
+                })
+
+            except Exception as e:
+                st.error(f"Error al conectar con Hugging Face API: {str(e)}")

requirements.txt

@@ -1,3 +1,4 @@
-altair
-pandas
-streamlit
+streamlit==1.32.2
+transformers==4.39.3
+huggingface-hub==0.22.2
+python-dotenv==1.0.1