Update app.py

app.py

@@ -1,57 +1,90 @@
 import streamlit as st
-from huggingface_hub import InferenceApi
-from typing import List, Tuple
+import openai
+import random
+import os
 
-# Cargar la API Key desde los secretos
-api_key = st.secrets["api_key"]
+# Configurar la API key de OpenAI desde la variable de entorno
+openai.api_key = os.environ.get("OPENAI_API_KEY")
 
-# Inicializar el cliente de la API de Hugging Face
-inference = InferenceApi(repo_id="gpt-4o-mini", token=api_key)
+# Verificar si la API key está configurada
+if not openai.api_key:
+    st.error("La API key de OpenAI no está configurada. Por favor, configúrala en las variables de entorno.")
+    st.stop()
 
+# El resto del código permanece igual
 contexto = """
-- Eres Citrino especializado en Dron, un asistente de voz amigable y servicial que hablas español, del Rio de la Plata. Hablar de manera informal -
-Responde brevemente a la solicitud del usuario y no proporciones información innecesaria. - 
-Si no entiendes la solicitud del usuario, pide aclaración. Usar espacios entre oraciones, emplear listas, no usar emojis ni otro formato en tus respuestas. 
-Responde de manera que sea fácil de leer por software de texto a voz.
-Unicamente responde a lo relacionado al dron, a la información de la ventana de contexto. Prohibido hablar de algun otro tema.
-Sugerir siempre algo mas relacionado al tema, la continuacion del tema especifico. Entender el contexto para incentivar el intercambio.
-En la primera interacción tienes que saludar a Gastón.
-
-CONCEPTOS BÁSICOS UAS, RPAS, drone o aeromodelo Se usan diferentes términos para referirnos a las aeronaves no tripuladas, pero ¿qué diferencias hay entre ellos? • Aeronave no tripulada o RPA (Remotely Piloted Aircraft) Cualquier aeronave que opere o esté diseñada para operar de forma autónoma o para ser pilotada a distancia sin un piloto a bordo. este RPA, es también llamado DAOD por DINACIA (Dispositivo aéreo operado a distancia)) • Dron (drone en inglés) Palabra coloquialmente usada para referirse en general a todas las aeronaves no tripuladas, debido a su similitud con un zumbido de Abejorro es otra forma de nombrar a los RPA • Aeromodelo Aeronave de tamaño reducido pilotado a distancia usada principalmente para vuelos deportivos o experimentales. también puede ser un RPA • RPAS «sistema de aeronave pilotada por control remoto» Aeronave pilotada a distancia, su sistema de vuelo, su estación, los enlaces requeridos de mando y control y cualquier otro componente según lo indicado en el diseño de la aeronave. • UAV « aeronave no tripulada» Aeronave no tripulada
+CONCEPTOS BÁSICOS UAS, RPAS, drone o aeromodelo:
+Se usan diferentes términos para referirnos a las aeronaves no tripuladas, pero ¿qué diferencias hay entre ellos?
+• Aeronave no tripulada o RPA (Remotely Piloted Aircraft): Cualquier aeronave que opere o esté diseñada para operar de forma autónoma o para ser pilotada a distancia sin un piloto a bordo. Este RPA, es también llamado DAOD por DINACIA (Dispositivo aéreo operado a distancia)
+• Dron (drone en inglés): Palabra coloquialmente usada para referirse en general a todas las aeronaves no tripuladas, debido a su similitud con un zumbido de Abejorro es otra forma de nombrar a los RPA
+• Aeromodelo: Aeronave de tamaño reducido pilotado a distancia usada principalmente para vuelos deportivos o experimentales. También puede ser un RPA
+• RPAS «sistema de aeronave pilotada por control remoto»: Aeronave pilotada a distancia, su sistema de vuelo, su estación, los enlaces requeridos de mando y control y cualquier otro componente según lo indicado en el diseño de la aeronave.
+• UAV « aeronave no tripulada»: Aeronave no tripulada, que tiene la capacidad de volar autónomamente y el equipo para controlarla de forma remota.
+• UAS «Unmanned Aircraft System»: El término UAS engloba los RPAS y las aeronaves autónomas es un término más genérico que se refiere a cualquier sistema de aeronaves no tripuladas, incluidos RPAS y UAV. (el piloto a distancia no puede intervenir durante el vuelo).
 """
 
-def generate_questions(api_key: str) -> List[str]:
-    prompt = f"Genera 38 preguntas de opción múltiple con 3 opciones cada una y la respuesta correcta, basadas en el siguiente contexto:\n\n{contexto}"
-    response = inference(inputs=prompt, parameters={"max_new_tokens": 1024, "return_full_text": False})
-    questions = response["generated_text"].strip().split("\n\n")
-    return questions
+def generar_preguntas(num_preguntas=38):
+    prompt = f"""Basándote en el siguiente contexto sobre drones y aeronaves no tripuladas, genera {num_preguntas} preguntas de opción múltiple. 
+    Cada pregunta debe tener tres opciones de respuesta y solo una debe ser correcta. 
+    Devuelve las preguntas en formato JSON como una lista de diccionarios, donde cada diccionario contenga las claves 'pregunta', 'opciones' (lista de 3 opciones), y 'respuesta_correcta' (índice de la opción correcta, 0, 1 o 2).
 
-def evaluate_answers(questions: List[str], user_answers: List[str]) -> Tuple[List[bool], List[str]]:
-    correct_answers = [q.split('\n')[-1].split(': ')[-1] for q in questions]
-    results = [user_answers[i] == correct_answers[i] for i in range(len(correct_answers))]
-    return results, correct_answers
+    Contexto:
+    {contexto}
+    """
 
-if "questions" not in st.session_state:
-    st.session_state.questions = generate_questions(api_key)
+    response = openai.ChatCompletion.create(
+        model="gpt-4o-mini",  # Asegúrate de que este es el nombre correcto del modelo
+        messages=[{"role": "system", "content": prompt}],
+        temperature=0.7,
+    )
 
-st.title("Evaluación de Drones")
+    # Asumimos que la respuesta está en formato JSON y la parseamos
+    import json
+    preguntas = json.loads(response.choices[0].message.content)
+    return preguntas
 
-form = st.form(key="quiz_form")
-user_answers = []
+def evaluar_respuestas(preguntas, respuestas_usuario):
+    correctas = 0
+    resultados = []
+    for i, (pregunta, respuesta_usuario) in enumerate(zip(preguntas, respuestas_usuario)):
+        if respuesta_usuario == pregunta['respuesta_correcta']:
+            correctas += 1
+            resultados.append(f"Pregunta {i+1}: Correcta")
+        else:
+            resultados.append(f"Pregunta {i+1}: Incorrecta. La respuesta correcta era: {pregunta['opciones'][pregunta['respuesta_correcta']]}")
+    return correctas, resultados
 
-for i, q in enumerate(st.session_state.questions):
-    question, *options = q.split('\n')
-    form.write(question)
-    user_answers.append(form.radio(f"Pregunta {i+1}", options))
+# Aplicación Streamlit
+st.title("Cuestionario de Drones")
 
-submit_button = form.form_submit_button(label="Enviar respuestas")
-
-if submit_button:
-    results, correct_answers = evaluate_answers(st.session_state.questions, user_answers)
-    st.write("Resultados:")
-    for i, result in enumerate(results):
-        st.write(f"Pregunta {i+1}: {'Correcta' if result else 'Incorrecta'} (Respuesta correcta: {correct_answers[i]})")
+# Inicializar o cargar preguntas
+if 'preguntas' not in st.session_state:
+    st.session_state.preguntas = generar_preguntas()
 
+# Botón para generar nuevas preguntas
 if st.button("Generar nuevas preguntas"):
-    st.session_state.questions = generate_questions(api_key)
-    st.experimental_rerun()
+    st.session_state.preguntas = generar_preguntas()
+    st.session_state.respuestas_enviadas = False
+
+# Formulario para las preguntas
+with st.form("quiz_form"):
+    respuestas_usuario = []
+    for i, pregunta in enumerate(st.session_state.preguntas):
+        st.write(f"**Pregunta {i+1}:** {pregunta['pregunta']}")
+        respuesta = st.radio(f"Selecciona una opción para la pregunta {i+1}:", 
+                             pregunta['opciones'], 
+                             key=f"pregunta_{i}")
+        respuestas_usuario.append(pregunta['opciones'].index(respuesta))
+
+    submitted = st.form_submit_button("Enviar respuestas")
+
+# Evaluar respuestas cuando se envía el formulario
+if submitted:
+    st.session_state.respuestas_enviadas = True
+    st.session_state.correctas, st.session_state.resultados = evaluar_respuestas(st.session_state.preguntas, respuestas_usuario)
+
+# Mostrar resultados
+if st.session_state.get('respuestas_enviadas', False):
+    st.write(f"Has acertado {st.session_state.correctas} de {len(st.session_state.preguntas)} preguntas.")
+    for resultado in st.session_state.resultados:
+        st.write(resultado)