Update src/app/main_app.py

src/app/main_app.py

@@ -1,11 +1,6 @@
-
 ###############################################################
 # main_app.py — Agentic Language Partner UI (Streamlit)
 ###############################################################
-
-import streamlit as st            # MUST BE FIRST
-from streamlit_audiorecorder import audiorecorder   # <-- ADD THIS
-
 import pandas as pd
 import json
 import random
@@ -14,18 +9,25 @@ from datetime import datetime
 from pathlib import Path
 from typing import Dict, List, Any
 
+import streamlit as st
+import streamlit.components.v1 as components
+from streamlit_audiorecorder import audiorecorder
 from deep_translator import GoogleTranslator
 
-# Local imports
-from src.app.auth import (
+from .auth import (
     authenticate_user,
     register_user,
     get_user_prefs,
     update_user_prefs,
 )
-from src.app.config import get_user_dir
-from src.app.conversation_core import ConversationManager
-from src.app.flashcards_tools import (
+from .config import get_user_dir
+from .conversation_core import (
+    ConversationManager,
+    load_whisper,
+    load_partner_lm,
+    load_nllb,
+)
+from .flashcards_tools import (
     list_user_decks,
     load_deck,
     _get_decks_dir,
@@ -33,9 +35,8 @@ from src.app.flashcards_tools import (
     generate_flashcards_from_text,
     generate_flashcards_from_ocr_results,
 )
-from src.app.ocr_tools import ocr_and_translate_batch
-from src.app.viewers import generate_flashcard_viewer_for_user
-
+from .ocr_tools import ocr_and_translate_batch
+from .viewers import generate_flashcard_viewer_for_user
 
 
 ###############################################################
@@ -51,14 +52,10 @@ st.set_page_config(
 st.markdown(
     """
 <style>
-
 .chat-column {
     display: flex;
     flex-direction: column;
 }
-
-
-
 /* Input bar at the top */
 .chat-input-bar {
     margin-bottom: 0.5rem;
@@ -67,7 +64,6 @@ st.markdown(
     border: 1px solid #333;
     border-radius: 0.5rem;
 }
-
 /* Scrollable chat messages below input */
 .chat-window {
     max-height: 65vh;
@@ -75,11 +71,9 @@ st.markdown(
     padding-right: .75rem;
     padding-bottom: 0.5rem;
 }
-
 /* Chat bubbles */
 .chat-row-user { justify-content:flex-end; display:flex; margin-bottom:.4rem; }
 .chat-row-assistant { justify-content:flex-start; display:flex; margin-bottom:.4rem; }
-
 .chat-bubble {
     border-radius:14px;
     padding:.55rem .95rem;
@@ -90,26 +84,21 @@ st.markdown(
 }
 .chat-bubble-user { background:#3a3b3c; color:white; }
 .chat-bubble-assistant { background:#1a73e8; color:white; }
-
 .chat-aux {
     font-size:1.0rem;   /* larger translation/explanation */
     color:#ccc;
     margin:0.1rem 0.25rem 0.5rem 0.25rem;
 }
-
 /* Lock viewport height and avoid infinite page scrolling */
 html, body {
     height: 100%;
     overflow: hidden !important;
 }
-
 .block-container {
     height: 100vh !important;
     overflow-y: auto !important;
 }
-
 .saved-conv-panel { max-width: 360px; }
-
 </style>
 """,
     unsafe_allow_html=True,
@@ -124,6 +113,10 @@ html, body {
 # ------------------------------------------------------------
 
 def preload_models():
+    """
+    Preloads Whisper, Qwen, and NLLB models only one time.
+    This prevents UI freeze or repeated loading during conversation.
+    """
     if st.session_state.get("models_loaded"):
         return
 
@@ -136,17 +129,14 @@ def preload_models():
             load_partner_lm()
         except Exception:
             pass
-        # If you don't have NLLB yet, comment this out
-        # try:
-        #     load_nllb()
-        # except Exception:
-        #     pass
+        try:
+            load_nllb()
+        except Exception:
+            pass
 
     st.session_state["models_loaded"] = True
 
 
-
-
 def get_conv_manager() -> ConversationManager:
     if "conv_manager" not in st.session_state:
         prefs = st.session_state["prefs"]
@@ -229,7 +219,6 @@ def save_current_conversation(username: str, name: str) -> Path:
     return path
 
 
-
 ###############################################################
 # CHAT HANDLING
 ###############################################################
@@ -411,7 +400,6 @@ def dashboard_tab(username: str):
     ###########################################################
     # MICROPHONE & TRANSCRIPTION CALIBRATION (native phrase)
     ###########################################################
-    # ---- Microphone & transcription calibration (restored original version) ----
     st.subheader("Microphone & Transcription Calibration")
 
     st.write(
@@ -467,9 +455,6 @@ def dashboard_tab(username: str):
 
     st.markdown("---")
 
-
-
-
     ###########################################################
     # TOOL OVERVIEW
     ###########################################################
@@ -479,18 +464,18 @@ def dashboard_tab(username: str):
     with c1:
         st.markdown("### 🎙️ Conversation Partner")
         st.write("Real-time language practice with microphone support.")
-
     with c2:
         st.markdown("### 🃏 Flashcards & Quizzes")
         st.write("Starter decks: Alphabet, Numbers, Greetings.")
-
     with c3:
         st.markdown("### 📷 OCR Helper")
         st.write("Upload images to extract and translate text.")
 
-# ------------------------------------------------------------
-# Settings tab  (restore missing function)
-# ------------------------------------------------------------
+
+###############################################################
+# SETTINGS TAB (minimal)
+###############################################################
+
 def settings_tab(username: str):
     """Minimal settings tab so main() can call it safely."""
     st.header("Settings")
@@ -510,15 +495,14 @@ def settings_tab(username: str):
     )
 
 
-
 ###############################################################
 # CONVERSATION TAB
 ###############################################################
 
 def conversation_tab(username: str):
-    import re
-    from datetime import datetime
-    from deep_translator import GoogleTranslator
+    import re as _re_local
+    from datetime import datetime as _dt_local
+    from deep_translator import GoogleTranslator as _GT
 
     st.header("Conversation")
 
@@ -542,7 +526,7 @@ def conversation_tab(username: str):
     show_exp = prefs.get("show_explanations", True)
 
     # ------------------------------------------
-    # RESET BUTTON (ONLY ONE)
+    # RESET BUTTON
     # ------------------------------------------
     if st.button("🔄 Reset Conversation"):
         st.session_state["chat_history"] = []
@@ -551,7 +535,6 @@ def conversation_tab(username: str):
         st.session_state["recorder_key"] += 1
         st.experimental_rerun()
 
-
     # ------------------------------------------
     # FIRST MESSAGE GREETING
     # ------------------------------------------
@@ -563,39 +546,38 @@ def conversation_tab(username: str):
             "english": "Hello! I heard you want to practice with me. How is your day going?",
             "german":  "Hallo! Ich habe gehört, dass du üben möchtest. Wie geht dein Tag bisher?",
             "spanish": "¡Hola! Escuché que querías practicar conmigo. ¿Cómo va tu día?",
-            "japanese":"こんにちは！練習したいと聞きました。今日はどんな一日ですか？",
+            "japanese": "こんにちは！練習したいと聞きました。今日はどんな一日ですか？",
         }
 
         intro = default_greetings.get(lang, default_greetings["english"])
 
         if topic and topic.lower() != "general conversation":
             try:
-                intro = GoogleTranslator(source="en", target=lang).translate(
+                intro = _GT(source="en", target=lang).translate(
                     f"Hello! Let's talk about {topic}. What do you think about it?"
                 )
             except Exception:
                 pass
 
         st.session_state["chat_history"].append(
-            {"role":"assistant","text":intro,"audio":None,"explanation":None}
+            {"role": "assistant", "text": intro, "audio": None, "explanation": None}
         )
 
     # ------------------------------------------
     # LAYOUT
     # ------------------------------------------
-    col_chat, col_saved = st.columns([3,1])
+    col_chat, col_saved = st.columns([3, 1])
 
     # ===========================
     # LEFT: CHAT WINDOW
     # ===========================
     with col_chat:
-
         st.markdown('<div class="chat-window">', 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"
+            row = "chat-row-user" if role == "user" else "chat-row-assistant"
 
             st.markdown(
                 f'<div class="{row}"><div class="chat-bubble {bubble}">{msg["text"]}</div></div>',
@@ -607,39 +589,49 @@ def conversation_tab(username: str):
 
             if role == "assistant":
                 try:
-                    tr = GoogleTranslator(source="auto", target=conv.native_language).translate(msg["text"])
+                    tr = _GT(source="auto", target=conv.native_language).translate(msg["text"])
                     st.markdown(f'<div class="chat-aux">{tr}</div>', unsafe_allow_html=True)
-                except: pass
+                except Exception:
+                    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()
+                    exp = _re_local.split(r"(?<=[.!?])\s+", exp)[0].strip()
+                    # Trim meta-ish stuff
+                    exp = _re_local.sub(
+                        r"(?i)(english version|the meaning|this sentence|the german sentence).*",
+                        "",
+                        exp,
+                    ).strip()
 
                     if exp:
                         st.markdown(f'<div class="chat-aux">{exp}</div>', unsafe_allow_html=True)
 
         # scroll
-        st.markdown("""
+        st.markdown(
+            """
             <script>
             setTimeout(() => {
                 let w = window.parent.document.getElementsByClassName('chat-window')[0];
                 if (w) w.scrollTop = w.scrollHeight;
             }, 200);
             </script>
-        """, unsafe_allow_html=True)
+            """,
+            unsafe_allow_html=True,
+        )
 
         # -------------------------------
         # AUDIO RECORDER
         # -------------------------------
         st.markdown('<div class="sticky-input-bar">', unsafe_allow_html=True)
 
-        audio = audiorecorder("🎤 Speak", "⏹ Stop",
-                              key=f"chat_audio_{st.session_state['recorder_key']}")
+        audio = audiorecorder(
+            "🎤 Speak",
+            "⏹ Stop",
+            key=f"chat_audio_{st.session_state['recorder_key']}",
+        )
 
         # ------------------------------------------
         # STATE: idle → record → transcribe
@@ -659,24 +651,20 @@ def conversation_tab(username: str):
         # 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])
+            c1, c2 = st.columns(2)
             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"
@@ -695,54 +683,55 @@ def conversation_tab(username: str):
 
         st.markdown("</div>", unsafe_allow_html=True)
 
-        # ======================================================
-        # RIGHT: SAVED CONVERSATIONS (RESTORED)
-        # ======================================================
-        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)
+    # ===========================
+    # RIGHT: SAVED CONVERSATIONS
+    # ===========================
+    with col_saved:
+        st.markdown("### Saved Conversations")
 
-            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)
+        default_name = datetime.utcnow().strftime("Session %Y-%m-%d %H:%M")
+        name_box = st.text_input("Name conversation", value=default_name)
 
-                    path = save_current_conversation(username, safe)
-                    st.success(f"Saved as {path.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)
+        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)
+        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", [])
+        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}")
+            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}",
+                    key=f"deckname_{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"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()
 
-                    if st.button(f"Delete {f.stem}", key=f"delete_{f.stem}"):
-                        f.unlink()
-                        st.experimental_rerun()
 
 ###############################################################
 # OCR TAB
@@ -761,7 +750,10 @@ def ocr_tab(username: str):
             return
 
         with st.spinner("Running OCR…"):
-            results = ocr_and_translate_batch([f.read() for f in imgs], target_lang=tgt)
+            results = ocr_and_translate_batch(
+                [f.read() for f in imgs],
+                target_lang=tgt,
+            )
 
         deck_path = generate_flashcards_from_ocr_results(
             username=username,
@@ -773,13 +765,30 @@ def ocr_tab(username: str):
         st.success(f"Deck saved: {deck_path}")
 
 
+###############################################################
+# FLASHCARD HELPERS
+###############################################################
+
+def _choose_next_card_index(cards):
+    """
+    Choose the next card index, preferring cards with lower score.
+    Very simple spaced-repetition style: pick randomly among the lowest-score cards.
+    """
+    if not cards:
+        return 0
+    scores = [c.get("score", 0) for c in cards]
+    min_score = min(scores)
+    candidates = [i for i, s in enumerate(scores) if s == min_score]
+    return random.choice(candidates)
+
+
 ###############################################################
 # FLASHCARDS TAB
 ###############################################################
 
 def flashcards_tab(username: str):
-    import pandas as pd
-    import re
+    import re as _re_local
+    import pandas as _pd_local
 
     # ---------------------------------------------------------
     # Helpers
@@ -788,7 +797,7 @@ def flashcards_tab(username: str):
     def normalize(s: str) -> str:
         """lowercase + strip non-alphanumerics for loose grading."""
         s = s.lower()
-        s = re.sub(r"[^a-z0-9]+", "", s)
+        s = _re_local.sub(r"[^a-z0-9]+", "", s)
         return s
 
     def card_front_html(text: str) -> str:
@@ -824,7 +833,6 @@ def flashcards_tab(username: str):
                 margin-right:auto;
                 box-shadow:0 4px 12px rgba(0,0,0,0.25);
             ">{front}</div>
-
             <div style="
                 background:#2b2b2b;
                 color:#f5f5f5;
@@ -948,7 +956,7 @@ def flashcards_tab(username: str):
                     ss[key + "show_back"] = False
                     st.experimental_rerun()
 
-            # DIFFICULTY GRADING (centered)
+            # DIFFICULTY GRADING
             st.markdown("### Rate this card")
             cA, cB, cC, cD, cE = st.columns(5)
 
@@ -961,19 +969,19 @@ def flashcards_tab(username: str):
                 st.experimental_rerun()
 
             with cA:
-                if st.button("🔥 Very Difficult", key=key+"g_vd"):
+                if st.button("🔥 Very Difficult", key=key + "g_vd"):
                     apply_grade(-2)
             with cB:
-                if st.button("😣 Hard", key=key+"g_h"):
+                if st.button("😣 Hard", key=key + "g_h"):
                     apply_grade(-1)
             with cC:
-                if st.button("😐 Neutral", key=key+"g_n"):
+                if st.button("😐 Neutral", key=key + "g_n"):
                     apply_grade(0)
             with cD:
-                if st.button("🙂 Easy", key=key+"g_e"):
+                if st.button("🙂 Easy", key=key + "g_e"):
                     apply_grade(1)
             with cE:
-                if st.button("🏆 Mastered", key=key+"g_m"):
+                if st.button("🏆 Mastered", key=key + "g_m"):
                     apply_grade(3)
 
         # ---------------------------------------------------
@@ -983,9 +991,15 @@ def flashcards_tab(username: str):
             # 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")
+                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"):
+                if st.button("Start Test", key=key + "begin"):
                     order = list(range(len(cards)))
                     random.shuffle(order)
                     order = order[:num_q]
@@ -995,7 +1009,6 @@ def flashcards_tab(username: str):
                     ss[key + "test_pos"] = 0
                     ss[key + "test_results"] = []
                     st.experimental_rerun()
-
             else:
                 order = ss[key + "test_order"]
                 pos = ss[key + "test_pos"]
@@ -1004,14 +1017,20 @@ def flashcards_tab(username: str):
                 # 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(
+                        f"### Test Complete — Score: {correct}/{len(results)} "
+                        f"({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}")
+                        st.write(
+                            f"**{i}.** {r['front']} → expected **{r['back']}**, "
+                            f"you answered *{r['user_answer']}* {emoji}"
+                        )
 
-                    if st.button("Restart Test", key=key+"restart"):
+                    if st.button("Restart Test", key=key + "restart"):
                         ss[key + "test_active"] = False
                         ss[key + "test_pos"] = 0
                         ss[key + "test_results"] = []
@@ -1029,54 +1048,55 @@ def flashcards_tab(username: str):
                 st.markdown(card_front_html(card["front"]), unsafe_allow_html=True)
 
                 # TTS
-                if st.button("🔊 Pronounce", key=key+f"tts_test_{pos}"):
+                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}")
+                user_answer = st.text_input("Your answer:", key=key + f"ans_{pos}")
 
-                if st.button("Submit Answer", key=key+f"submit_{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,
-                    })
+                    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)
+    # DECK AT A GLANCE
     # =======================================================
     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),
-        })
+        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
 ###############################################################
@@ -1201,7 +1221,7 @@ def main():
 
     tab_dash, tab_conv, tab_ocr, tab_flash, tab_quiz, tab_settings = tabs
 
-    # restore active tab (required so Streamlit shows correct tab on rerun)
+    # restore active tab
     _ = tabs[st.session_state["active_tab"]]
 
     with tab_dash:
@@ -1229,8 +1249,5 @@ def main():
         settings_tab(username)
 
 
-
 if __name__ == "__main__":
     main()
-
-