', unsafe_allow_html=True)
for msg in st.session_state["chat_history"]:
role = msg["role"]
bubble = "chat-bubble-user" if role == "user" else "chat-bubble-assistant"
row = "chat-row-user" if role == "user" else "chat-row-assistant"
st.markdown(
f'
',
unsafe_allow_html=True,
)
if role == "assistant" and msg.get("audio"):
st.audio(msg["audio"], format="audio/mp3")
if role == "assistant":
try:
tr = GoogleTranslator(source="auto", target=conv.native_language).translate(msg["text"])
st.markdown(f'
{tr}
', unsafe_allow_html=True)
except:
pass
if show_exp and msg.get("explanation"):
exp = msg["explanation"]
# Force EXACTLY ONE sentence
exp = re.split(r"(?<=[.!?])\s+", exp)[0].strip()
# Remove any meta nonsense ("version:", "meaning:", "this sentence", etc)
exp = re.sub(r"(?i)(english version|the meaning|this sentence|the german sentence).*", "", exp).strip()
if exp:
st.markdown(f'
{exp}
', unsafe_allow_html=True)
# scroll
st.markdown("""
""", unsafe_allow_html=True)
# -------------------------------
# AUDIO UPLOAD / RECORDING
# -------------------------------
st.markdown('
', unsafe_allow_html=True)
audio_file = st.file_uploader(
"🎤 Upload or record an audio message",
type=["wav", "mp3", "m4a", "ogg"],
key=f"chat_audio_{st.session_state['recorder_key']}",
)
# ------------------------------------------
# STATE: idle → file → transcribe
# ------------------------------------------
if st.session_state["speech_state"] == "idle":
if audio_file is not None:
raw = audio_file.read()
try:
seg = AudioSegment.from_file(BytesIO(raw))
seg = seg.set_frame_rate(16000).set_channels(1)
with st.spinner("Transcribing…"):
txt, lang, conf = conv.transcribe(seg, spoken_lang=conv.target_language)
st.session_state["pending_transcript"] = txt.strip()
st.session_state["speech_state"] = "pending_speech"
st.session_state["recorder_key"] += 1
st.experimental_rerun()
except Exception as e:
st.error(f"Audio decode/transcription error: {e}")
# ------------------------------------------
# STATE: pending_speech → confirm
# ------------------------------------------
if st.session_state["speech_state"] == "pending_speech":
st.write("### Confirm your spoken message:")
st.info(st.session_state["pending_transcript"])
c1, c2 = st.columns([1,1])
with c1:
if st.button("Send message", key="send_pending"):
txt = st.session_state["pending_transcript"]
with st.spinner("Partner is responding…"):
handle_user_message(username, txt)
# cleanup
st.session_state["speech_state"] = "idle"
st.session_state["pending_transcript"] = ""
st.session_state["recorder_key"] += 1
st.experimental_rerun()
with c2:
if st.button("Discard", key="discard_pending"):
st.session_state["speech_state"] = "idle"
st.session_state["pending_transcript"] = ""
st.session_state["recorder_key"] += 1
st.experimental_rerun()
# -------------------------------
# TYPED TEXT INPUT
# -------------------------------
typed = st.text_input("Type your message:", key="typed_input")
if typed.strip() and st.button("Send typed message"):
handle_user_message(username, typed.strip())
st.session_state["typed_input"] = ""
st.experimental_rerun()
st.markdown("
", unsafe_allow_html=True)
# ======================================================
# RIGHT: SAVED CONVERSATIONS
# ======================================================
with col_saved:
from pathlib import Path
import json
st.markdown("### Saved Conversations")
default_name = datetime.utcnow().strftime("Session %Y-%m-%d %H:%M")
name_box = st.text_input("Name conversation", value=default_name)
if st.button("Save conversation"):
if not st.session_state["chat_history"]:
st.warning("Nothing to save.")
else:
safe = re.sub(r"[^0-9A-Za-z_-]", "_", name_box)
path = save_current_conversation(username, safe)
st.success(f"Saved as {path.name}")
saved_dir = get_user_dir(username) / "chats" / "saved"
saved_dir.mkdir(parents=True, exist_ok=True)
files = sorted(saved_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
for f in files:
data = json.loads(f.read_text())
sess_name = data.get("name", f.stem)
msgs = data.get("messages", [])
with st.expander(f"{sess_name} ({len(msgs)} msgs)"):
deck_name = st.text_input(f"Deck name for {sess_name}", value=f"deck_{f.stem}")
if st.button(f"Export {f.stem}", key=f"export_{f.stem}"):
body = "\n".join(m["text"] for m in msgs if m["role"] == "assistant")
deck_path = generate_flashcards_from_text(
username=username,
text=body,
deck_name=deck_name,
target_lang=prefs["native_language"],
tags=["conversation"],
)
st.success(f"Deck exported: {deck_path.name}")
if st.button(f"Delete {f.stem}", key=f"delete_{f.stem}"):
f.unlink()
st.experimental_rerun()
###############################################################
# OCR TAB
###############################################################
def ocr_tab(username: str):
st.header("OCR → Flashcards")
imgs = st.file_uploader("Upload images", ["png", "jpg", "jpeg"], accept_multiple_files=True)
tgt = st.selectbox("Translate to", ["en", "de", "ja", "zh-cn", "es"])
deck_name = st.text_input("Deck name", "ocr_vocab")
if st.button("Create Deck from OCR"):
if not imgs:
st.warning("Upload at least one image.")
return
with st.spinner("Running OCR…"):
results = ocr_and_translate_batch([f.read() for f in imgs], target_lang=tgt)
deck_path = generate_flashcards_from_ocr_results(
username=username,
ocr_results=results,
deck_name=deck_name,
target_lang=tgt,
tags=["ocr"],
)
st.success(f"Deck saved: {deck_path}")
###############################################################
# FLASHCARDS TAB
###############################################################
def flashcards_tab(username: str):
import pandas as pd
import re
# ---------------------------------------------------------
# Helpers
# ---------------------------------------------------------
def normalize(s: str) -> str:
"""lowercase + strip non-alphanumerics for loose grading."""
s = s.lower()
s = re.sub(r"[^a-z0-9]+", "", s)
return s
def card_front_html(text: str) -> str:
return f"""
{text}
"""
def card_back_html(front: str, back: str) -> str:
return f"""
"""
# ---------------------------------------------------------
# Load deck
# ---------------------------------------------------------
st.header("Flashcards")
decks = list_user_decks(username)
if not decks:
st.info("No decks available yet.")
return
deck_name = st.selectbox("Select deck", sorted(decks.keys()))
deck_path = decks[deck_name]
deck = load_deck(deck_path)
cards = deck.get("cards", [])
tags = deck.get("tags", [])
if not cards:
st.warning("Deck is empty.")
return
st.write(f"Total cards: **{len(cards)}**")
if tags:
st.caption("Tags: " + ", ".join(tags))
# Delete deck button
if st.button("Delete deck"):
deck_path.unlink()
st.experimental_rerun()
# ---------------------------------------------------------
# Session state setup
# ---------------------------------------------------------
key = f"fc_{deck_name}_"
ss = st.session_state
if key + "init" not in ss:
ss[key + "mode"] = "Study"
ss[key + "idx"] = 0
ss[key + "show_back"] = False
# test state
ss[key + "test_active"] = False
ss[key + "test_order"] = []
ss[key + "test_pos"] = 0
ss[key + "test_results"] = []
ss[key + "init"] = True
conv = get_conv_manager()
mode = st.radio("Mode", ["Study", "Test"], horizontal=True, key=key + "mode")
st.markdown("---")
# =======================================================
# CENTER PANEL
# =======================================================
with st.container():
# ---------------------------------------------------
# STUDY MODE
# ---------------------------------------------------
if mode == "Study":
idx = ss[key + "idx"] % len(cards)
card = cards[idx]
show_back = ss[key + "show_back"]
st.markdown("### Study Mode")
st.markdown("---")
# CARD DISPLAY
if not show_back:
st.markdown(card_front_html(card["front"]), unsafe_allow_html=True)
if st.button("🔊 Pronounce", key=key + f"tts_front_{idx}"):
audio = conv.text_to_speech(card["front"])
if audio:
st.audio(audio, format="audio/mp3")
else:
st.markdown(card_back_html(card["front"], card["back"]), unsafe_allow_html=True)
if st.button("🔊 Pronounce", key=key + f"tts_back_{idx}"):
audio = conv.text_to_speech(card["back"])
if audio:
st.audio(audio, format="audio/mp3")
# FLIPBOOK CONTROLS
st.markdown("---")
c1, c2, c3 = st.columns(3)
with c1:
if st.button("Flip", key=key + "flip"):
ss[key + "show_back"] = not show_back
st.experimental_rerun()
with c2:
if st.button("Shuffle deck", key=key + "shuf"):
random.shuffle(cards)
deck["cards"] = cards
save_deck(deck_path, deck)
ss[key + "idx"] = 0
ss[key + "show_back"] = False
st.experimental_rerun()
with c3:
if st.button("Next →", key=key + "next"):
ss[key + "idx"] = (idx + 1) % len(cards)
ss[key + "show_back"] = False
st.experimental_rerun()
# DIFFICULTY GRADING (centered)
st.markdown("### Rate this card")
cA, cB, cC, cD, cE = st.columns(5)
def _choose_next_card_index(cards_list):
# Simple heuristic: prefer lower-score / less-reviewed cards
scored = []
for i, c in enumerate(cards_list):
score = c.get("score", 0)
reviews = c.get("reviews", 0)
priority = score - 0.3 * reviews
scored.append((priority, i))
scored.sort(key=lambda x: x[0])
return scored[0][1] if scored else 0
def apply_grade(delta):
card["score"] = max(0, card.get("score", 0) + delta)
card["reviews"] = card.get("reviews", 0) + 1
save_deck(deck_path, deck)
ss[key + "idx"] = _choose_next_card_index(cards)
ss[key + "show_back"] = False
st.experimental_rerun()
with cA:
if st.button("🔥 Very Difficult", key=key+"g_vd"):
apply_grade(-2)
with cB:
if st.button("😣 Hard", key=key+"g_h"):
apply_grade(-1)
with cC:
if st.button("😐 Neutral", key=key+"g_n"):
apply_grade(0)
with cD:
if st.button("🙂 Easy", key=key+"g_e"):
apply_grade(1)
with cE:
if st.button("🏆 Mastered", key=key+"g_m"):
apply_grade(3)
# ---------------------------------------------------
# TEST MODE
# ---------------------------------------------------
else:
# Initial test setup
if not ss[key + "test_active"]:
st.markdown("### Test Setup")
num_q = st.slider("Number of questions", 3, min(20, len(cards)), min(5, len(cards)), key=key+"nq")
if st.button("Start Test", key=key+"begin"):
order = list(range(len(cards)))
random.shuffle(order)
order = order[:num_q]
ss[key + "test_active"] = True
ss[key + "test_order"] = order
ss[key + "test_pos"] = 0
ss[key + "test_results"] = []
st.experimental_rerun()
else:
order = ss[key + "test_order"]
pos = ss[key + "test_pos"]
results = ss[key + "test_results"]
# Test Complete
if pos >= len(order):
correct = sum(r["correct"] for r in results)
st.markdown(f"### Test Complete — Score: {correct}/{len(results)} ({correct/len(results)*100:.1f}%)")
st.markdown("---")
for i, r in enumerate(results, 1):
emoji = "✅" if r["correct"] else "❌"
st.write(f"**{i}.** {r['front']} → expected **{r['back']}**, you answered *{r['user_answer']}* {emoji}")
if st.button("Restart Test", key=key+"restart"):
ss[key + "test_active"] = False
ss[key + "test_pos"] = 0
ss[key + "test_results"] = []
ss[key + "test_order"] = []
st.experimental_rerun()
return
# Current question
cid = order[pos]
card = cards[cid]
st.progress(pos / len(order))
st.caption(f"Question {pos+1} / {len(order)}")
st.markdown(card_front_html(card["front"]), unsafe_allow_html=True)
# TTS
if st.button("🔊 Pronounce", key=key+f"tts_test_{pos}"):
audio = conv.text_to_speech(card["front"])
if audio:
st.audio(audio, format="audio/mp3")
user_answer = st.text_input("Your answer:", key=key+f"ans_{pos}")
if st.button("Submit Answer", key=key+f"submit_{pos}"):
ua = user_answer.strip()
correct = normalize(ua) == normalize(card["back"])
# Flash feedback
if correct:
st.success("Correct!")
else:
st.error(f"Incorrect — expected: {card['back']}")
results.append({
"front": card["front"],
"back": card["back"],
"user_answer": ua,
"correct": correct,
})
ss[key + "test_results"] = results
ss[key + "test_pos"] = pos + 1
st.experimental_rerun()
# =======================================================
# DECK AT A GLANCE (FULL WIDTH)
# =======================================================
st.markdown("---")
st.subheader("Deck at a glance")
df_rows = []
for i, c in enumerate(cards, start=1):
df_rows.append({
"#": i,
"Front": c.get("front", ""),
"Back": c.get("back", ""),
"Score": c.get("score", 0),
"Reviews": c.get("reviews", 0),
})
st.dataframe(pd.DataFrame(df_rows), height=500, use_container_width=True)
###############################################################
# QUIZ TAB
###############################################################
def quiz_tab(username: str):
st.header("Quiz")
ensure_default_decks(username)
user_dir = get_user_dir(username)
quiz_dir = user_dir / "quizzes"
quiz_dir.mkdir(exist_ok=True)
decks = list_user_decks(username)
if not decks:
st.info("No decks.")
return
selected = st.multiselect("Use decks", sorted(decks.keys()))
if not selected:
return
num_q = st.slider("Questions", 3, 20, 6)
if st.button("Generate quiz"):
pool = []
for name in selected:
pool.extend(load_deck(decks[name])["cards"])
questions = []
for _ in range(num_q):
c = random.choice(pool)
qtype = random.choice(["mc", "fill"])
if qtype == "mc":
others = random.sample(pool, min(3, len(pool) - 1))
opts = [c["back"]] + [x["back"] for x in others]
random.shuffle(opts)
questions.append(
{"type": "mc", "prompt": c["front"], "options": opts, "answer": c["back"]}
)
else:
questions.append(
{"type": "fill", "prompt": c["front"], "answer": c["back"]}
)
qid = datetime.utcnow().strftime("quiz_%Y%m%d_%H%M%S")
quiz = {"id": qid, "questions": questions}
(quiz_dir / f"{qid}.json").write_text(json.dumps(quiz, indent=2))
st.session_state["quiz"] = quiz
st.session_state["quiz_idx"] = 0
st.session_state["quiz_answers"] = {}
st.success("Quiz created!")
if "quiz" not in st.session_state:
return
quiz = st.session_state["quiz"]
qs = quiz["questions"]
idx = st.session_state["quiz_idx"]
if idx >= len(qs):
correct = sum(1 for v in st.session_state["quiz_answers"].values() if v["correct"])
st.success(f"Score: {correct}/{len(qs)}")
if st.button("New quiz"):
del st.session_state["quiz"]
del st.session_state["quiz_idx"]
del st.session_state["quiz_answers"]
return
q = qs[idx]
st.subheader(f"Question {idx+1}/{len(qs)}")
st.markdown(f"**{q['prompt']}**")
if q["type"] == "mc":
choice = st.radio("Choose:", q["options"], key=f"mc_{idx}")
if st.button("Submit", key=f"sub_{idx}"):
st.session_state["quiz_answers"][idx] = {
"given": choice,
"correct": choice == q["answer"],
}
st.session_state["quiz_idx"] += 1
st.experimental_rerun()
else:
ans = st.text_input("Your answer", key=f"fill_{idx}")
if st.button("Submit", key=f"sub_{idx}"):
st.session_state["quiz_answers"][idx] = {
"given": ans,
"correct": ans.strip().lower() == q["answer"].lower(),
}
st.session_state["quiz_idx"] += 1
st.experimental_rerun()
###############################################################
# MAIN
###############################################################
def main():
# ---------- AUTH ----------
if "user" not in st.session_state:
login_view()
return
username = st.session_state["user"]
st.sidebar.write(f"Logged in as **{username}**")
if st.sidebar.button("Log out"):
st.session_state.clear()
st.experimental_rerun()
# ---------- LOAD MODELS + PREFS ----------
preload_models()
sidebar_settings(username)
ensure_default_decks(username)
# ---------- TAB PERSISTENCE ----------
if "active_tab" not in st.session_state:
st.session_state["active_tab"] = 0
tab_labels = ["Dashboard", "Conversation", "OCR", "Flashcards", "Quiz", "Settings"]
tabs = st.tabs(tab_labels)
tab_dash, tab_conv, tab_ocr, tab_flash, tab_quiz, tab_settings = tabs
# restore active tab (required so Streamlit shows correct tab on rerun)
_ = tabs[st.session_state["active_tab"]]
with tab_dash:
st.session_state["active_tab"] = 0
dashboard_tab(username)
with tab_conv:
st.session_state["active_tab"] = 1
conversation_tab(username)
with tab_ocr:
st.session_state["active_tab"] = 2
ocr_tab(username)
with tab_flash:
st.session_state["active_tab"] = 3
flashcards_tab(username)
with tab_quiz:
st.session_state["active_tab"] = 4
quiz_tab(username)
with tab_settings:
st.session_state["active_tab"] = 5
settings_tab(username)
if __name__ == "__main__":
main()