Create app.py

Inicio de la app

app.py

@@ -0,0 +1,167 @@
+import streamlit as st
+import os
+import random
+import numpy as np
+
+# Verificación de la importación de la biblioteca de la API de Google y configuración de la API KEY
+try:
+    import google.generativeai as genai
+    gemini_api_key = os.getenv("GEMINI_API_KEY")
+    if gemini_api_key is None:
+        raise ValueError("La variable de entorno GEMINI_API_KEY no está configurada.")
+    genai.configure(api_key=gemini_api_key)
+    model = genai.GenerativeModel('gemini-pro')
+except ImportError:
+    st.error("Error al importar la biblioteca de Google. Asegúrate de que está instalada.")
+    st.stop()
+except ValueError as e:
+    st.error(e)
+    st.stop()
+
+def get_game_state():
+    """Obtiene el estado actual del juego"""
+    if 'aciertos' not in st.session_state:
+        st.session_state.aciertos = 0
+    if 'errores' not in st.session_state:
+        st.session_state.errores = 0
+    if 'nivel' not in st.session_state:
+        st.session_state.nivel = 0  # 0 = Principiante, 1 = Intermedio, 2 = Difícil
+    if 'nuevo_problema' not in st.session_state:
+        st.session_state.nuevo_problema = True
+    return st.session_state.aciertos, st.session_state.errores, st.session_state.nivel, st.session_state.nuevo_problema
+
+def update_game_state(aciertos, errores, nivel, nuevo_problema):
+    """Actualiza el estado del juego"""
+    st.session_state.aciertos = aciertos
+    st.session_state.errores = errores
+    st.session_state.nivel = nivel
+    st.session_state.nuevo_problema = nuevo_problema
+
+def chat_with_model(user_input):
+    """Envía una pregunta al modelo de IA y obtiene una respuesta."""
+    try:
+        response = model.generate_content(user_input)
+        return response.text
+    except Exception as e:
+        return f"Error al generar contenido: {e}"
+
+def tiene_solucion_unica(matriz_coeficientes, matriz_resultados):
+    """Determina si un sistema de ecuaciones tiene solución única."""
+    try:
+        np.linalg.solve(matriz_coeficientes, matriz_resultados)
+        return True
+    except np.linalg.LinAlgError:
+        return False
+
+def generar_ecuacion_y_respuestas():
+    """Genera una ecuación lineal con una solución y tres respuestas incorrectas."""
+    a = random.randint(1, 10)
+    b = random.randint(-10, 10)
+    c = random.randint(-10, 10)
+    x = (c - b) / a
+    respuestas_incorrectas = set()
+    while len(respuestas_incorrectas) < 3:
+        respuesta_erronea = x + random.choice([-2, -1, 1, 2]) * random.random()
+        respuestas_incorrectas.add(round(respuesta_erronea, 2))
+    respuestas = list(respuestas_incorrectas) + [round(x, 2)]
+    random.shuffle(respuestas)
+    ecuacion = f"{a}x + ({b}) = {c}" if b < 0 else f"{a}x + {b} = {c}"
+    return ecuacion, respuestas, round(x, 2)
+
+def generar_sistema_ecuaciones_2x2_y_respuestas():
+    """Genera un sistema de ecuaciones lineales 2x2 con solución única y tres respuestas incorrectas."""
+    while True:
+        a, b, e = random.randint(1, 10), random.randint(1, 10), random.randint(-10, 10)
+        c, d, f = random.randint(1, 10), random.randint(1, 10), random.randint(-10, 10)
+        if tiene_solucion_unica(np.array([[a, b], [c, d]]), np.array([e, f])):
+            break
+    matriz_coeficientes = np.array([[a, b], [c, d]])
+    matriz_resultados = np.array([e, f])
+    soluciones = np.linalg.solve(matriz_coeficientes, matriz_resultados)
+    respuestas_incorrectas = {(round(soluciones[0] + random.choice([-2, -1, 1, 2]) * random.random(), 2), 
+                               round(soluciones[1] + random.choice([-2, -1, 1, 2]) * random.random(), 2)) 
+                              for _ in range(3)}
+    respuestas_correctas = (round(soluciones[0], 2), round(soluciones[1], 2))
+    respuestas = list(respuestas_incorrectas) + [respuestas_correctas]
+    random.shuffle(respuestas)
+    sistema = f"{a}x + {b}y = {e}\n\n\n{c}x + {d}y = {f}"
+    return sistema, respuestas, respuestas_correctas
+
+def generar_sistema_ecuaciones_3x3_y_respuestas():
+    """Genera un sistema de ecuaciones lineales 3x3 con solución única y tres respuestas incorrectas."""
+    while True:
+        a, b, c, e = random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(-10, 10)
+        d, f, g, h = random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(-10, 10)
+        i, j, k, l = random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(-10, 10)
+        matriz_coeficientes = np.array([[a, b, c], [d, f, g], [i, j, k]])
+        matriz_resultados = np.array([e, h, l])
+        if tiene_solucion_unica(matriz_coeficientes, matriz_resultados):
+            break
+    soluciones = np.linalg.solve(matriz_coeficientes, matriz_resultados)
+    respuestas_incorrectas = {(round(soluciones[0] + random.choice([-2, -1, 1, 2]) * random.random(), 2),
+                               round(soluciones[1] + random.choice([-2, -1, 1, 2]) * random.random(), 2),
+                               round(soluciones[2] + random.choice([-2, -1, 1, 2]) * random.random(), 2)) 
+                              for _ in range(3)}
+    respuestas_correctas = (round(soluciones[0], 2), round(soluciones[1], 2), round(soluciones[2], 2))
+    respuestas = list(respuestas_incorrectas) + [respuestas_correctas]
+    random.shuffle(respuestas)
+    sistema = f"{a}x + {b}y + {c}z = {e}\n\n\n{d}x + {f}y + {g}z = {h}\n\n\n{i}x + {j}y + {k}z = {l}"
+    return sistema, respuestas, respuestas_correctas
+
+def manejar_respuesta(problema, respuesta_elegida, respuesta_correcta, nivel):
+    """Evalúa la respuesta del usuario, proporcionando retroalimentación y una explicación."""
+    tolerancia = 1e-9
+    correcto = False
+    if nivel == 2:  # Sistema 3x3
+        correcto = all(abs(e - c) < tolerancia for e, c in zip(respuesta_elegida, respuesta_correcta))
+    elif nivel == 1:  # Sistema 2x2
+        correcto = all(abs(e - c) < tolerancia for e, c in zip(respuesta_elegida, respuesta_correcta))
+    else:  # Ecuación lineal
+        correcto = abs(respuesta_elegida - respuesta_correcta) < tolerancia
+    if correcto:
+        resultado = "¡Correcto! +1 punto."
+        aciertos, errores, _, _ = get_game_state()
+        if aciertos == 9:
+            st.success("Felicitaciones, has pasado al nivel Difícil: Sistemas de ecuaciones lineales 3x3")
+        update_game_state(aciertos + 1, errores, aciertos // 10, True)
+    else:
+        resultado = "Incorrecto, sigue practicando."
+        aciertos, errores, _, _ = get_game_state()
+        update_game_state(aciertos, errores + 1, aciertos // 10, True)
+    explicacion = chat_with_model(f"Explica el problema '{problema}' y por qué la respuesta {respuesta_elegida} es {'correcta' if correcto else 'incorrecta'}.")
+    return resultado + f" Escogiste la respuesta: {respuesta_elegida}. La respuesta correcta es: {respuesta_correcta}.\n{explicacion}"
+
+# Interfaz de usuario y lógica de la aplicación
+st.title("Desafío de Matemáticas")
+st.markdown("Intenta resolver el problema y selecciona tu respuesta.")
+
+aciertos, errores, nivel, nuevo_problema = get_game_state()
+
+niveles = ["Principiante", "Intermedio", "Difícil"]
+nivel_actual = niveles[nivel]
+st.sidebar.markdown(f"Nivel: {nivel_actual}")
+st.sidebar.write(f"Aciertos: {aciertos}")
+st.sidebar.write(f"Errores: {errores}")
+
+if nuevo_problema:
+    if nivel == 2:
+        problema_actual, respuestas, respuesta_correcta = generar_sistema_ecuaciones_3x3_y_respuestas()
+    elif nivel == 1:
+        problema_actual, respuestas, respuesta_correcta = generar_sistema_ecuaciones_2x2_y_respuestas()
+    else:
+        problema_actual, respuestas, respuesta_correcta = generar_ecuacion_y_respuestas()
+    update_game_state(aciertos, errores, nivel, False)
+
+st.write(problema_actual)
+opciones = [", ".join(map(str, r)) if isinstance(r, tuple) else str(r) for r in respuestas]
+seleccion = st.radio("Elige tu respuesta", opciones, key="opciones")
+respuesta_elegida = tuple(map(float, seleccion.split(', '))) if "," in seleccion else float(seleccion)
+
+if st.button("Enviar"):
+    resultado = manejar_respuesta(problema_actual, respuesta_elegida, respuesta_correcta, nivel)
+    st.write(resultado)
+
+boton_nuevo_problema = st.button("Generar Nuevo Problema")
+if boton_nuevo_problema:
+    update_game_state(aciertos, errores, nivel, True)
+    st.experimental_rerun()