Update src/app/main_app.py

src/app/main_app.py

@@ -11,8 +11,9 @@ 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
+from pydub import AudioSegment
+from io import BytesIO
 
 from .auth import (
     authenticate_user,
@@ -21,12 +22,7 @@ from .auth import (
     update_user_prefs,
 )
 from .config import get_user_dir
-from .conversation_core import (
-    ConversationManager,
-    load_whisper,
-    load_partner_lm,
-    load_nllb,
-)
+from .conversation_core import ConversationManager
 from .flashcards_tools import (
     list_user_decks,
     load_deck,
@@ -120,6 +116,8 @@ def preload_models():
     if st.session_state.get("models_loaded"):
         return
 
+    from .conversation_core import load_whisper, load_partner_lm, load_nllb
+
     with st.spinner("Loading language & speech models (one-time)…"):
         try:
             load_whisper()
@@ -406,28 +404,30 @@ def dashboard_tab(username: str):
         "To verify that audio recording and transcription are working, "
         "please repeat this phrase in your native language:\n\n"
         "> \"Hello, my name is [Your Name], and I am here to practice languages.\"\n\n"
-        "Record a short clip and then run transcription to check accuracy."
+        "Upload or record a short clip and then run transcription to check accuracy."
     )
 
     calib_col1, calib_col2 = st.columns([2, 1])
 
     with calib_col1:
-        calib_audio = audiorecorder(
-            "🎤 Start calibration",
-            "⏹ Stop",
+        calib_file = st.file_uploader(
+            "Upload or record a short audio sample (e.g., WAV/MP3)",
+            type=["wav", "mp3", "m4a", "ogg"],
             key="calibration_audio",
         )
 
-        if len(calib_audio) > 0:
-            st.caption("Calibration audio recorded. Click 'Transcribe sample' to test.")
+        if calib_file is not None:
+            st.caption("Calibration audio loaded. Click 'Transcribe sample' to test.")
 
         if st.button("Transcribe sample", key="calibration_transcribe"):
-            if len(calib_audio) == 0:
-                st.warning("Please record a short calibration clip first.")
+            if calib_file is None:
+                st.warning("Please upload or record a short calibration clip first.")
             else:
                 conv = get_conv_manager()
                 try:
-                    seg = calib_audio.set_frame_rate(16000).set_channels(1)
+                    raw = calib_file.read()
+                    seg = AudioSegment.from_file(BytesIO(raw))
+                    seg = seg.set_frame_rate(16000).set_channels(1)
                     with st.spinner("Transcribing calibration audio…"):
                         text_out, det_lang, det_prob = conv.transcribe(
                             seg,
@@ -463,19 +463,20 @@ def dashboard_tab(username: str):
     c1, c2, c3 = st.columns(3)
     with c1:
         st.markdown("### 🎙️ Conversation Partner")
-        st.write("Real-time language practice with microphone support.")
+        st.write("Real-time language practice with microphone support (via audio uploads).")
+
     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 (minimal)
-###############################################################
-
+# ------------------------------------------------------------
+# Settings tab  (restore missing function)
+# ------------------------------------------------------------
 def settings_tab(username: str):
     """Minimal settings tab so main() can call it safely."""
     st.header("Settings")
@@ -500,9 +501,9 @@ def settings_tab(username: str):
 ###############################################################
 
 def conversation_tab(username: str):
-    import re as _re_local
-    from datetime import datetime as _dt_local
-    from deep_translator import GoogleTranslator as _GT
+    import re
+    from datetime import datetime
+    from deep_translator import GoogleTranslator
 
     st.header("Conversation")
 
@@ -526,7 +527,7 @@ def conversation_tab(username: str):
     show_exp = prefs.get("show_explanations", True)
 
     # ------------------------------------------
-    # RESET BUTTON
+    # RESET BUTTON (ONLY ONE)
     # ------------------------------------------
     if st.button("🔄 Reset Conversation"):
         st.session_state["chat_history"] = []
@@ -546,38 +547,39 @@ 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 = _GT(source="en", target=lang).translate(
+                intro = GoogleTranslator(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>',
@@ -589,82 +591,85 @@ def conversation_tab(username: str):
 
             if role == "assistant":
                 try:
-                    tr = _GT(source="auto", target=conv.native_language).translate(msg["text"])
+                    tr = GoogleTranslator(source="auto", target=conv.native_language).translate(msg["text"])
                     st.markdown(f'<div class="chat-aux">{tr}</div>', unsafe_allow_html=True)
-                except Exception:
+                except: 
                     pass
 
                 if show_exp and msg.get("explanation"):
                     exp = msg["explanation"]
 
                     # Force EXACTLY ONE sentence
-                    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()
+                    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'<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
+        # AUDIO UPLOAD / RECORDING
         # -------------------------------
         st.markdown('<div class="sticky-input-bar">', unsafe_allow_html=True)
 
-        audio = audiorecorder(
-            "🎤 Speak",
-            "⏹ Stop",
+        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 → record → transcribe
+        # STATE: idle → file → transcribe
         # ------------------------------------------
         if st.session_state["speech_state"] == "idle":
-            if audio and len(audio) > 0:
-                seg = audio.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()
+            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(2)
+            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"
@@ -683,54 +688,54 @@ def conversation_tab(username: str):
 
         st.markdown("</div>", unsafe_allow_html=True)
 
-    # ===========================
-    # RIGHT: SAVED CONVERSATIONS
-    # ===========================
-    with col_saved:
-        st.markdown("### Saved Conversations")
+        # ======================================================
+        # RIGHT: SAVED CONVERSATIONS
+        # ======================================================
+        with col_saved:
+            from pathlib import Path
+            import json
 
-        default_name = datetime.utcnow().strftime("Session %Y-%m-%d %H:%M")
-        name_box = st.text_input("Name conversation", value=default_name)
+            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)
-                path = save_current_conversation(username, safe)
-                st.success(f"Saved as {path.name}")
+            default_name = datetime.utcnow().strftime("Session %Y-%m-%d %H:%M")
+            name_box = st.text_input("Name conversation", value=default_name)
 
-        saved_dir = get_user_dir(username) / "chats" / "saved"
-        saved_dir.mkdir(parents=True, exist_ok=True)
+            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)
 
-        files = sorted(saved_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
+                    path = save_current_conversation(username, safe)
+                    st.success(f"Saved as {path.name}")
 
-        for f in files:
-            data = json.loads(f.read_text())
-            sess_name = data.get("name", f.stem)
-            msgs = data.get("messages", [])
+            saved_dir = get_user_dir(username) / "chats" / "saved"
+            saved_dir.mkdir(parents=True, exist_ok=True)
 
-            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}",
-                )
+            files = sorted(saved_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
 
-                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()
+            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()
 
 
 ###############################################################
@@ -750,10 +755,7 @@ 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,
@@ -765,30 +767,13 @@ 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 re as _re_local
-    import pandas as _pd_local
+    import pandas as pd
+    import re
 
     # ---------------------------------------------------------
     # Helpers
@@ -797,7 +782,7 @@ def flashcards_tab(username: str):
     def normalize(s: str) -> str:
         """lowercase + strip non-alphanumerics for loose grading."""
         s = s.lower()
-        s = _re_local.sub(r"[^a-z0-9]+", "", s)
+        s = re.sub(r"[^a-z0-9]+", "", s)
         return s
 
     def card_front_html(text: str) -> str:
@@ -956,10 +941,21 @@ def flashcards_tab(username: str):
                     ss[key + "show_back"] = False
                     st.experimental_rerun()
 
-            # DIFFICULTY GRADING
+            # 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
@@ -969,19 +965,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)
 
         # ---------------------------------------------------
@@ -991,15 +987,9 @@ 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]
@@ -1009,6 +999,7 @@ 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"]
@@ -1017,20 +1008,14 @@ 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)} "
-                        f"({correct/len(results)*100:.1f}%)"
-                    )
+                    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']}**, "
-                            f"you answered *{r['user_answer']}* {emoji}"
-                        )
+                        st.write(f"**{i}.** {r['front']} → expected **{r['back']}**, 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"] = []
@@ -1048,51 +1033,48 @@ 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
+    # 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),
-            }
-        )
+        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)
 
@@ -1221,7 +1203,7 @@ def main():
 
     tab_dash, tab_conv, tab_ocr, tab_flash, tab_quiz, tab_settings = tabs
 
-    # restore active tab
+    # restore active tab (required so Streamlit shows correct tab on rerun)
     _ = tabs[st.session_state["active_tab"]]
 
     with tab_dash: