MatD / app_old3.py
AnnaAneta's picture
Rename app.py to app_old3.py
aa16dde verified
Raw History Blame Contribute Delete
10.7 kB
import json, gradio as gr
from rapidfuzz import fuzz, process
import sympy as sp
import re
# --- Wczytaj bazę wiedzy ---
DATA = json.load(open("knowledge.json", "r", encoding="utf-8"))
def pretty_factorial(expr):
"""Zamienia gamma(x) → (x-1)! w dowolnym kontekście."""
expr_str = str(expr)
# regex dopasowujący np. gamma(n), gamma(n+1), gamma(k-1)
pattern = r"gamma\(([^)]+)\)"
def repl(match):
inner = match.group(1).strip()
return f"({inner}-1)!"
expr_str = re.sub(pattern, repl, expr_str)
return expr_str
def parse_recurrence_equation(equation_text):
"""
Analizuje rekurencję w postaci:
a_0*T_0 = c_0
a_n*T_n = b_n*T_{n-1} + c_n
Zwraca: a_0, a_n, b_n, c_n, c_0, initials
"""
import re, sympy as sp
# Naprawiamy brak separatora między warunkiem początkowym a równaniem
equation_text = re.sub(r"(T_0\s*=\s*[0-9\+\-\*/\^\(\)n]+)\s+(?=[0-9]+\*?T_n)", r"\1; ", equation_text)
equation_text = equation_text.replace("^", "**")
equation_text = re.sub(r"\s+", " ", equation_text.strip())
n = sp.Symbol("n")
T = sp.Function("T")
print("=== RAW INPUT ===")
print(equation_text)
# Znajdujemy równanie główne (a_n*T_n = b_n*T_{n-1} + c_n)
match_eq = re.search(r"([0-9\*\^\+\-\sT_n\{\}\(\)n]+=[^=]+)$", equation_text)
if not match_eq:
raise ValueError("Nie udało się rozpoznać równania rekurencji w treści.")
eq_part = match_eq.group(1)
expr_text = eq_part.replace("T_{n-1}", "T(n-1)").replace("T_n", "T(n)")
lhs_str, rhs_str = expr_text.split("=")
lhs = sp.sympify(lhs_str)
rhs = sp.sympify(rhs_str)
a_n = lhs.expand().coeff(T(n)) or 1
b_n = rhs.expand().coeff(T(n-1)) or 0
c_n = sp.simplify(rhs - b_n*T(n-1))
# --- Warunki początkowe --- (T_0=1, 2*T_0=5, itp.)
initials = re.findall(r"([0-9\*\^\+\-\s]*)T_([0-9]+)\s*=\s*([0-9\+\-\*/\^\(\)n]+)", equation_text)
a_0 = sp.Integer(1)
c_0 = None
inits = []
for coeff_str, idx_str, val_str in initials:
idx = int(idx_str)
val = sp.sympify(val_str)
coeff_str = coeff_str.strip()
if idx == 0:
a_0 = sp.sympify(coeff_str) if coeff_str else sp.Integer(1)
c_0 = val
inits.append((idx, val))
# --- Obliczenie T_0 ---
if c_0 is not None:
try:
T_0 = sp.simplify(c_0 / a_0)
except Exception:
T_0 = None
else:
T_0 = None
#obliczenie b_1
try:
n = sp.Symbol("n")
b1 = sp.simplify(sp.sympify(str(b_n)).subs(n, 1))
except Exception:
b1 = "?"
#żeby sam obliczył i uprościł S_n dla odczytanych współczynników
try:
n = sp.Symbol("n", integer=True, positive=True)
i = sp.Symbol("i", integer=True, positive=True)
# a_n, b_n muszą być sympy
a_i_sub = a_n.subs(n, i)
b_i_sub = b_n.subs(n, i)
# --- NAJWAŻNIEJSZY PATCH ---
# SymPy źle upraszcza (n-1)! do n**(n-1) w pewnych ścieżkach.
# Dlatego NA SIŁĘ obsługujemy poprawnie najczęstszy przypadek.
if sp.simplify(b_i_sub - 1) == 0 and sp.simplify(a_i_sub - i) == 0:
# Czyli a_n = n oraz b_n = 1
# Wtedy S_n = a_0 * (n-1)!
S_n_expr = a_0 * sp.factorial(n - 1)
S_n = pretty_factorial(str(S_n_expr))
else:
# Ogólny przypadek
prod_a = sp.Product(a_i_sub, (i, 1, n - 1))
prod_b = sp.Product(b_i_sub, (i, 1, n))
S_n_expr = (a_0 * prod_a) / prod_b
S_n_simpl = sp.simplify(S_n_expr)
S_n = S_n_simpl
except Exception as e:
S_n = "?"
print("a_0:", a_0, " a_n:", a_n, "b_n:", b_n," c_n:", c_n," c_0:", c_0," T_0:", T_0)
print("DEBUG S_n sympy:", S_n)
return {
"a_0": pretty_factorial(a_0),
"a_n": pretty_factorial(a_n),
"b_n": pretty_factorial(b_n),
"c_n": pretty_factorial(c_n),
"b_1": pretty_factorial(str(b1)),
"S_n": pretty_factorial(str(S_n)),
"c_0": c_0,
"T_0": T_0, # <-- dodane
"initials": inits
}
# --- Dopasowanie podobnych zadań ---
def find_similar(query, top_k=3):
corpus = [(i, d["statement"] + " | " + d.get("topic", "") + " | " + d.get("group_id", ""))
for i, d in enumerate(DATA)]
choices = [c[1] for c in corpus]
results = process.extract(query, choices, scorer=fuzz.token_set_ratio, limit=top_k)
return [DATA[corpus[r[2]][0]] for r in results]
# --- Tryb wskazówek ---
def hint_mode(user_problem, step_idx=0):
try:
coeffs = parse_recurrence_equation(user_problem)
for k, v in coeffs.items():
if hasattr(v, "__str__"):
coeffs[k] = str(v)
except Exception:
coeffs = {"a_0": "?", "a_n": "?", "b_n": "?", "c_n": "?", "c_0": "?", "initials": []}
hits = find_similar(user_problem, top_k=1)
if not hits:
return "Nie znalazłam podobnego zadania. Spróbuj dodać więcej kontekstu.", step_idx, coeffs
z = hits[0]
sol = z.get("solution", {})
tips = sol.get("tips", [])
total = len(tips)
if not tips:
return "Brak wskazówek w bazie.", step_idx, coeffs
if step_idx >= total:
return "🎓 To już ostatnia wskazówka.", step_idx, coeffs
tip = tips[step_idx]
msg = f"**Wskazówka {step_idx+1}/{total}** (na podstawie *{z['title']}*):\n\n➡️ {tip}"
#msg = f"**Wskazówka {step_idx+1}/{total}** (na podstawie *{z['title']}*):\n\n$$ {tip} $$"
return msg, step_idx, coeffs
# --- Pokaż realizację wskazówki ---
def show_solution(user_problem, step_idx, coeffs):
hits = find_similar(user_problem, top_k=1)
if not hits:
return "Nie znaleziono zadania."
z = hits[0]
sol = z.get("solution", {})
tips_solutions = sol.get("tips_solutions", [])
if step_idx >= len(tips_solutions):
return "Brak rozwiązania dla tej wskazówki."
tip_sol_template = tips_solutions[step_idx]
# Konwertujemy wszystkie wartości na string
coeffs_for_format = {k: str(v) for k, v in coeffs.items()}
#Rozwiązanie: użycie string.Formatter z bezpiecznym fallback-Python pozwala nadpisać zachowanie format_map() używając własnej klasy,
#która zwraca oryginalny tekst dla nieznanych kluczy:
# Klasa SafeDict zostawia nieznane placeholdery w szablonie
#class SafeDict(dict):
# def __missing__(self, key):
# return "{" + key + "}"
class SafeDict(dict):
def __missing__(self, key):
# pozostaw latexowe indeksy i podobne konstrukcje nietknięte
if "=" in key or not key.isidentifier():
return "{" + key + "}"
return "{" + key + "}"
try:
# <-- kluczowa zmiana: używamy format_map z SafeDict
tip_sol = tip_sol_template.format_map(SafeDict(coeffs_for_format))
except Exception:
tip_sol = tip_sol_template
#try:
# tip_sol = tip_sol_template.format(**coeffs_for_format)
# except KeyError as e:
# tip_sol = f"Nie udało się podstawić zmiennej: {e}"
#except Exception:
# tip_sol = tip_sol_template
#return f"🧩 **Realizacja wskazówki {step_idx+1}:**\n\n{tip_sol}"
latex_text = f"🧩 **Realizacja wskazówki {step_idx+1}:**\n\n$$ {tip_sol} $$"
return latex_text
# --- Tryb weryfikacji ---
def verify_mode(user_problem, user_answer):
hits = find_similar(user_problem, top_k=1)
if not hits:
return "Nie znalazłam podobnego zadania."
z = hits[0]
gold = z.get("solution", {}).get("final", "")
if not gold:
return "Brak wzorcowej odpowiedzi."
try:
x, n = sp.symbols("x n")
ue = sp.simplify(sp.sympify(user_answer))
ge = sp.simplify(sp.sympify(gold))
ok = sp.simplify(ue - ge) == 0
verdict = "✅ Wynik zgodny z rozwiązaniem wzorcowym." if ok else "❌ Wynik różni się od wzorca."
return f"**Weryfikacja** ({z['title']}):\n\n{verdict}"
except Exception as e:
return f"Nie udało się porównać wyrażeń: {e}"
# --- Interfejs Gradio ---
with gr.Blocks() as demo:
gr.Markdown("# 🤖 AI-TutorMD — interaktywny tryb wskazówek (z resetem)")
gr.Markdown("Podaj rekurencję i przechodź krok po kroku. Przy zmianie zadania rozmowa się resetuje.")
chatbot = gr.Chatbot(label="Rozmowa z AI-Tutorem", height=400)
inp = gr.Textbox(label="Treść zadania", placeholder="np. T_0=1 4*T_n = 5*T_{n-1} + 2**n")
ans = gr.Textbox(label="Twój wynik", placeholder="np. (5**n - 1)/4")
step_state = gr.State(0)
coeffs_state = gr.State({})
history_state = gr.State([])
with gr.Row():
btn_first = gr.Button("🧩 Pierwsza wskazówka")
btn_next = gr.Button("➡️ Kolejna wskazówka")
btn_show = gr.Button("👁 Pokaż realizację wskazówki")
btn_verify = gr.Button("🔍 Weryfikuj wynik")
# --- Logika przycisków ---
def first_hint(user_problem, history):
msg, step_idx, coeffs = hint_mode(user_problem, 0)
history.append((user_problem, msg))
return history, step_idx, coeffs
def next_hint(user_problem, history, step_idx):
msg, new_idx, coeffs = hint_mode(user_problem, step_idx + 1)
history.append(("➡️ Kolejna wskazówka", msg))
return history, new_idx, coeffs
def show_current_solution(user_problem, history, step_idx, coeffs):
msg = show_solution(user_problem, step_idx, coeffs)
history.append(("👁 Pokaż realizację wskazówki", msg))
return history
def verify(user_problem, user_answer, history):
msg = verify_mode(user_problem, user_answer)
history.append((f"🧮 {user_problem} = {user_answer}", msg))
return history
# --- RESET przy zmianie treści zadania ---
def reset_session(_):
return [], 0, {}
inp.change(fn=reset_session, inputs=inp,
outputs=[chatbot, step_state, coeffs_state])
# --- Podpięcie przycisków ---
btn_first.click(first_hint, inputs=[inp, history_state],
outputs=[chatbot, step_state, coeffs_state])
btn_next.click(next_hint, inputs=[inp, chatbot, step_state],
outputs=[chatbot, step_state, coeffs_state])
btn_show.click(show_current_solution, inputs=[inp, chatbot, step_state, coeffs_state],
outputs=chatbot)
btn_verify.click(verify, inputs=[inp, ans, chatbot], outputs=chatbot)
gr.Markdown("---\n💡 Zmiana treści zadania automatycznie resetuje rozmowę i licznik kroków.")
demo.launch()