Update app.py

app.py

@@ -1,19 +1,5 @@
 import streamlit as st
-import anthropic
-import openai
-import base64
-import cv2
-import glob
-import json
-import math
-import os
-import pytz
-import random
-import re
-import requests
-import textract
-import time
-import zipfile
+import anthropic, openai, base64, cv2, glob, json, math, os, pytz, random, re, requests, textract, time, zipfile
 import plotly.graph_objects as go
 import streamlit.components.v1 as components
 from datetime import datetime
@@ -34,13 +20,10 @@ from streamlit.runtime.scriptrunner import get_script_run_ctx
 import asyncio
 import edge_tts
 from streamlit_marquee import streamlit_marquee
-from typing import Tuple, Optional
-import pandas as pd
 
 # ─────────────────────────────────────────────────────────
 # 1. CORE CONFIGURATION & SETUP
 # ─────────────────────────────────────────────────────────
-
 st.set_page_config(
     page_title="🚲TalkingAIResearcher🏆",
     page_icon="🚲🏆",
@@ -54,7 +37,7 @@ st.set_page_config(
 )
 load_dotenv()
 
-# ▶ Available English voices for Edge TTS
+# Available English voices for Edge TTS
 EDGE_TTS_VOICES = [
     "en-US-AriaNeural",
     "en-US-GuyNeural",
@@ -67,7 +50,7 @@ EDGE_TTS_VOICES = [
     "en-CA-LiamNeural"
 ]
 
-# ▶ Initialize Session State
+# Session state variables
 if 'marquee_settings' not in st.session_state:
     st.session_state['marquee_settings'] = {
         "background": "#1E1E1E",
@@ -77,50 +60,53 @@ if 'marquee_settings' not in st.session_state:
         "width": "100%",
         "lineHeight": "35px"
     }
+
 if 'tts_voice' not in st.session_state:
     st.session_state['tts_voice'] = EDGE_TTS_VOICES[0]
+
 if 'audio_format' not in st.session_state:
     st.session_state['audio_format'] = 'mp3'
+
 if 'transcript_history' not in st.session_state:
     st.session_state['transcript_history'] = []
+
 if 'chat_history' not in st.session_state:
     st.session_state['chat_history'] = []
+
 if 'openai_model' not in st.session_state:
     st.session_state['openai_model'] = "gpt-4o-2024-05-13"
+
 if 'messages' not in st.session_state:
     st.session_state['messages'] = []
+
 if 'last_voice_input' not in st.session_state:
     st.session_state['last_voice_input'] = ""
+
 if 'editing_file' not in st.session_state:
     st.session_state['editing_file'] = None
+
 if 'edit_new_name' not in st.session_state:
     st.session_state['edit_new_name'] = ""
+
 if 'edit_new_content' not in st.session_state:
     st.session_state['edit_new_content'] = ""
+
 if 'viewing_prefix' not in st.session_state:
     st.session_state['viewing_prefix'] = None
+
 if 'should_rerun' not in st.session_state:
     st.session_state['should_rerun'] = False
+
 if 'old_val' not in st.session_state:
     st.session_state['old_val'] = None
+
 if 'last_query' not in st.session_state:
     st.session_state['last_query'] = ""
+
 if 'marquee_content' not in st.session_state:
     st.session_state['marquee_content'] = "🚀 Welcome to TalkingAIResearcher | 🤖 Your Research Assistant"
 
-# ▶ Additional keys for performance, caching, etc.
-if 'audio_cache' not in st.session_state:
-    st.session_state['audio_cache'] = {}
-if 'download_link_cache' not in st.session_state:
-    st.session_state['download_link_cache'] = {}
-if 'operation_timings' not in st.session_state:
-    st.session_state['operation_timings'] = {}
-if 'performance_metrics' not in st.session_state:
-    st.session_state['performance_metrics'] = defaultdict(list)
-if 'enable_audio' not in st.session_state:
-    st.session_state['enable_audio'] = True  # Turn TTS on/off
-
-# ▶ API Keys
+# API Keys
 openai_api_key = os.getenv('OPENAI_API_KEY', "")
 anthropic_key = os.getenv('ANTHROPIC_API_KEY_3', "")
 xai_key = os.getenv('xai',"")
@@ -134,7 +120,7 @@ openai_client = OpenAI(api_key=openai.api_key, organization=os.getenv('OPENAI_OR
 HF_KEY = os.getenv('HF_KEY')
 API_URL = os.getenv('API_URL')
 
-# ▶ Helper constants
+# Helper constants
 FILE_EMOJIS = {
     "md": "📝",
     "mp3": "🎵",
@@ -142,77 +128,20 @@ FILE_EMOJIS = {
 }
 
 # ─────────────────────────────────────────────────────────
-# 2. PERFORMANCE MONITORING & TIMING
-# ─────────────────────────────────────────────────────────
-
-class PerformanceTimer:
-    """
-    ⏱️ A context manager for timing operations with automatic logging.
-    Usage:
-        with PerformanceTimer("my_operation"):
-            # do something
-    The duration is stored into `st.session_state['operation_timings']`
-    and appended to the `performance_metrics` list.
-    """
-    def __init__(self, operation_name: str):
-        self.operation_name = operation_name
-        self.start_time = None
-        
-    def __enter__(self):
-        self.start_time = time.time()
-        return self
-        
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if not exc_type:  # Only log if no exception occurred
-            duration = time.time() - self.start_time
-            st.session_state['operation_timings'][self.operation_name] = duration
-            st.session_state['performance_metrics'][self.operation_name].append(duration)
-
-def log_performance_metrics():
-    """
-    📈 Display performance metrics in the sidebar, including a timing breakdown
-    and a small bar chart of average times.
-    """
-    st.sidebar.markdown("### ⏱️ Performance Metrics")
-    
-    metrics = st.session_state['operation_timings']
-    if metrics:
-        total_time = sum(metrics.values())
-        st.sidebar.write(f"**Total Processing Time:** {total_time:.2f}s")
-        
-        # Break down each operation time
-        for operation, duration in metrics.items():
-            percentage = (duration / total_time) * 100
-            st.sidebar.write(f"**{operation}:** {duration:.2f}s ({percentage:.1f}%)")
-            
-        # Show timing history chart
-        history_data = []
-        for op, times in st.session_state['performance_metrics'].items():
-            if times:  # Only if we have data
-                avg_time = sum(times) / len(times)
-                history_data.append({"Operation": op, "Avg Time (s)": avg_time})
-        
-        if history_data:
-            st.sidebar.markdown("### 📊 Timing History (Avg)")
-            chart_data = pd.DataFrame(history_data)
-            st.sidebar.bar_chart(chart_data.set_index("Operation"))
-
-# ─────────────────────────────────────────────────────────
-# 3. HELPER FUNCTIONS (FILENAMES, LINKS, MARQUEE, ETC.)
+# 2. HELPER FUNCTIONS
 # ─────────────────────────────────────────────────────────
 
 def get_central_time():
-    """🌎 Get current time in US Central timezone."""
+    """Get current time in US Central timezone."""
     central = pytz.timezone('US/Central')
     return datetime.now(central)
 
 def format_timestamp_prefix():
-    """📅 Generate a timestamp prefix: MM_dd_yy_hh_mm_AM/PM."""
+    """Generate timestamp prefix in format MM_dd_yy_hh_mm_AM/PM."""
     ct = get_central_time()
     return ct.strftime("%m_%d_%y_%I_%M_%p")
 
 def initialize_marquee_settings():
-    """🌈 Initialize marquee defaults if needed."""
     if 'marquee_settings' not in st.session_state:
         st.session_state['marquee_settings'] = {
             "background": "#1E1E1E",
@@ -224,12 +153,11 @@ def initialize_marquee_settings():
         }
 
 def get_marquee_settings():
-    """🔧 Retrieve marquee settings from session."""
     initialize_marquee_settings()
     return st.session_state['marquee_settings']
 
 def update_marquee_settings_ui():
-    """🖌 Add color pickers & sliders for marquee config in the sidebar."""
+    """Add color pickers & sliders for marquee config in sidebar."""
     st.sidebar.markdown("### 🎯 Marquee Settings")
     cols = st.sidebar.columns(2)
     with cols[0]:
@@ -241,7 +169,7 @@ def update_marquee_settings_ui():
                                     key="text_color_picker")
     with cols[1]:
         font_size = st.slider("📏 Size", 10, 24, 14, key="font_size_slider")
-        duration = st.slider("⏱️ Speed (secs)", 1, 20, 20, key="duration_slider")
+        duration = st.slider("⏱️ Speed", 1, 20, 20, key="duration_slider")
 
     st.session_state['marquee_settings'].update({
         "background": bg_color,
@@ -251,10 +179,7 @@ def update_marquee_settings_ui():
     })
 
 def display_marquee(text, settings, key_suffix=""):
-    """
-    🎉 Show a marquee text with style from the marquee settings.
-    Automatically truncates text to ~280 chars to avoid overflow.
-    """
+    """Show marquee text with style from settings."""
     truncated_text = text[:280] + "..." if len(text) > 280 else text
     streamlit_marquee(
         content=truncated_text,
@@ -264,10 +189,7 @@ def display_marquee(text, settings, key_suffix=""):
     st.write("")
 
 def get_high_info_terms(text: str, top_n=10) -> list:
-    """
-    📌 Extract top_n frequent words & bigrams (excluding common stopwords).
-    Useful for generating short descriptive keywords from Q/A content.
-    """
+    """Extract top_n freq words or bigrams (excluding stopwords)."""
     stop_words = set(['the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with'])
     words = re.findall(r'\b\w+(?:-\w+)*\b', text.lower())
     bi_grams = [' '.join(pair) for pair in zip(words, words[1:])]
@@ -277,24 +199,22 @@ def get_high_info_terms(text: str, top_n=10) -> list:
     return [term for term, freq in counter.most_common(top_n)]
 
 def clean_text_for_filename(text: str) -> str:
-    """
-    🏷️ Remove special chars & short unhelpful words from text for safer filenames.
-    Returns a lowercased, underscore-joined token string.
-    """
+    """Remove special chars, short words, etc. for filenames."""
     text = text.lower()
     text = re.sub(r'[^\w\s-]', '', text)
     words = text.split()
+    # remove short or unhelpful words
     stop_short = set(['the', 'and', 'for', 'with', 'this', 'that', 'ai', 'library'])
     filtered = [w for w in words if len(w) > 3 and w not in stop_short]
     return '_'.join(filtered)[:200]
 
 def generate_filename(prompt, response, file_type="md", max_length=200):
     """
-    📁 Create a shortened filename based on prompt+response content:
-      1) Extract top info terms,
-      2) Combine snippet from prompt+response,
-      3) Remove duplicates,
-      4) Truncate if needed.
+    Generate a shortened filename by:
+      1) extracting high-info terms,
+      2) snippet from prompt+response,
+      3) remove duplicates,
+      4) truncate if needed.
     """
     prefix = format_timestamp_prefix() + "_"
     combined_text = (prompt + " " + response)[:200]  
@@ -302,7 +222,7 @@ def generate_filename(prompt, response, file_type="md", max_length=200):
     snippet = (prompt[:40] + " " + response[:40]).strip()
     snippet_cleaned = clean_text_for_filename(snippet)
     
-    # Remove duplicates
+    # remove duplicates
     name_parts = info_terms + [snippet_cleaned]
     seen = set()
     unique_parts = []
@@ -319,160 +239,88 @@ def generate_filename(prompt, response, file_type="md", max_length=200):
     return f"{prefix}{full_name}.{file_type}"
 
 def create_file(prompt, response, file_type="md"):
-    """
-    📝 Create a text file from prompt + response with a sanitized filename.
-    Returns the created filename.
-    """
+    """Create a text file from prompt + response with sanitized filename."""
     filename = generate_filename(prompt.strip(), response.strip(), file_type)
     with open(filename, 'w', encoding='utf-8') as f:
         f.write(prompt + "\n\n" + response)
     return filename
 
-# ─────────────────────────────────────────────────────────
-# 4. OPTIMIZED AUDIO GENERATION (ASYNC TTS + CACHING)
-# ─────────────────────────────────────────────────────────
-
-def clean_for_speech(text: str) -> str:
-    """
-    🔉 Clean up text for TTS output with enhanced cleaning.
-    Removes markdown, code blocks, links, etc.
-    """
-    with PerformanceTimer("text_cleaning"):
-        # Remove markdown headers
-        text = re.sub(r'#+ ', '', text)
-        # Remove link formats [text](url)
-        text = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', text)
-        # Remove emphasis markers (*, _, ~, `)
-        text = re.sub(r'[*_~`]', '', text)
-        # Remove code blocks
-        text = re.sub(r'```[\s\S]*?```', '', text)
-        text = re.sub(r'`[^`]*`', '', text)
-        # Remove excess whitespace
-        text = re.sub(r'\s+', ' ', text).replace("\n", " ")
-        # Remove hidden S tokens
-        text = text.replace("</s>", " ")
-        # Remove URLs
-        text = re.sub(r'https?://\S+', '', text)
-        text = re.sub(r'\(https?://[^\)]+\)', '', text)
-        text = text.strip()
-        return text
-
-async def async_edge_tts_generate(
-    text: str,
-    voice: str,
-    rate: int = 0,
-    pitch: int = 0,
-    file_format: str = "mp3"
-) -> Tuple[Optional[str], float]:
-    """
-    🎶 Asynchronous TTS generation with caching and performance tracking.
-    Returns (filename, generation_time).
-    """
-    with PerformanceTimer("tts_generation") as timer:
-        # ▶ Clean & validate text
-        text = clean_for_speech(text)
-        if not text.strip():
-            return None, 0
-        
-        # ▶ Check cache (avoid regenerating the same TTS)
-        cache_key = f"{text[:100]}_{voice}_{rate}_{pitch}_{file_format}"
-        if cache_key in st.session_state['audio_cache']:
-            return st.session_state['audio_cache'][cache_key], 0
-        
-        try:
-            # ▶ Generate audio
-            rate_str = f"{rate:+d}%"
-            pitch_str = f"{pitch:+d}Hz"
-            communicate = edge_tts.Communicate(text, voice, rate=rate_str, pitch=pitch_str)
-            
-            # ▶ Generate unique filename
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            filename = f"audio_{timestamp}_{random.randint(1000, 9999)}.{file_format}"
-            
-            # ▶ Save audio file
-            await communicate.save(filename)
-            
-            # ▶ Store in cache
-            st.session_state['audio_cache'][cache_key] = filename
-            
-            # ▶ Return path + timing
-            return filename, time.time() - timer.start_time
-        
-        except Exception as e:
-            st.error(f"❌ Error generating audio: {str(e)}")
-            return None, 0
-
-async def async_save_qa_with_audio(
-    question: str,
-    answer: str,
-    voice: Optional[str] = None
-) -> Tuple[str, Optional[str], float, float]:
+def get_download_link(file, file_type="zip"):
     """
-    📝 Asynchronously save Q&A to markdown, then generate audio if enabled.
-    Returns (md_file, audio_file, md_time, audio_time).
+    Convert a file to base64 and return an HTML link for download.
     """
-    voice = voice or st.session_state['tts_voice']
-    
-    with PerformanceTimer("qa_save") as timer:
-        # ▶ Save Q/A as markdown
-        md_start = time.time()
-        md_file = create_file(question, answer, "md")
-        md_time = time.time() - md_start
-        
-        # ▶ Generate audio (if globally enabled)
-        audio_file = None
-        audio_time = 0
-        if st.session_state['enable_audio']:
-            audio_text = f"{question}\n\nAnswer: {answer}"
-            audio_file, audio_time = await async_edge_tts_generate(
-                audio_text,
-                voice=voice,
-                file_format=st.session_state['audio_format']
-            )
-        
-        return md_file, audio_file, md_time, audio_time
+    with open(file, "rb") as f:
+        b64 = base64.b64encode(f.read()).decode()
+    if file_type == "zip":
+        return f'<a href="data:application/zip;base64,{b64}" download="{os.path.basename(file)}">📂 Download {os.path.basename(file)}</a>'
+    elif file_type == "mp3":
+        return f'<a href="data:audio/mpeg;base64,{b64}" download="{os.path.basename(file)}">🎵 Download {os.path.basename(file)}</a>'
+    elif file_type == "wav":
+        return f'<a href="data:audio/wav;base64,{b64}" download="{os.path.basename(file)}">🔊 Download {os.path.basename(file)}</a>'
+    elif file_type == "md":
+        return f'<a href="data:text/markdown;base64,{b64}" download="{os.path.basename(file)}">📝 Download {os.path.basename(file)}</a>'
+    else:
+        return f'<a href="data:application/octet-stream;base64,{b64}" download="{os.path.basename(file)}">Download {os.path.basename(file)}</a>'
 
-def create_download_link_with_cache(file_path: str, file_type: str = "mp3") -> str:
-    """
-    ⬇️ Create a download link for a file with caching & error handling.
-    """
-    with PerformanceTimer("download_link_generation"):
-        cache_key = f"dl_{file_path}"
-        if cache_key in st.session_state['download_link_cache']:
-            return st.session_state['download_link_cache'][cache_key]
-        
-        try:
-            with open(file_path, "rb") as f:
-                b64 = base64.b64encode(f.read()).decode()
-            filename = os.path.basename(file_path)
-            
-            if file_type == "mp3":
-                link = f'<a href="data:audio/mpeg;base64,{b64}" download="{filename}">🎵 Download {filename}</a>'
-            elif file_type == "wav":
-                link = f'<a href="data:audio/wav;base64,{b64}" download="{filename}">🔊 Download {filename}</a>'
-            elif file_type == "md":
-                link = f'<a href="data:text/markdown;base64,{b64}" download="{filename}">📝 Download {filename}</a>'
-            else:
-                link = f'<a href="data:application/octet-stream;base64,{b64}" download="{filename}">⬇️ Download {filename}</a>'
-            
-            st.session_state['download_link_cache'][cache_key] = link
-            return link
-        
-        except Exception as e:
-            st.error(f"❌ Error creating download link: {str(e)}")
-            return ""
+def clean_for_speech(text: str) -> str:
+    """Clean up text for TTS output."""
+    text = text.replace("\n", " ")
+    text = text.replace("</s>", " ")
+    text = text.replace("#", "")
+    text = re.sub(r"\(https?:\/\/[^\)]+\)", "", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+async def edge_tts_generate_audio(text, voice="en-US-AriaNeural", rate=0, pitch=0, file_format="mp3"):
+    """Async TTS generation with edge-tts library."""
+    text = clean_for_speech(text)
+    if not text.strip():
+        return None
+    rate_str = f"{rate:+d}%"
+    pitch_str = f"{pitch:+d}Hz"
+    communicate = edge_tts.Communicate(text, voice, rate=rate_str, pitch=pitch_str)
+    out_fn = generate_filename(text, text, file_type=file_format)
+    await communicate.save(out_fn)
+    return out_fn
+
+def speak_with_edge_tts(text, voice="en-US-AriaNeural", rate=0, pitch=0, file_format="mp3"):
+    """Wrapper for the async TTS generate call."""
+    return asyncio.run(edge_tts_generate_audio(text, voice, rate, pitch, file_format))
+
+def play_and_download_audio(file_path, file_type="mp3"):
+    """Streamlit audio + a quick download link."""
+    if file_path and os.path.exists(file_path):
+        st.audio(file_path)
+        dl_link = get_download_link(file_path, file_type=file_type)
+        st.markdown(dl_link, unsafe_allow_html=True)
+
+def save_qa_with_audio(question, answer, voice=None):
+    """Save Q&A to markdown and also generate audio."""
+    if not voice:
+        voice = st.session_state['tts_voice']
+    
+    combined_text = f"# Question\n{question}\n\n# Answer\n{answer}"
+    md_file = create_file(question, answer, "md")
+    audio_text = f"{question}\n\nAnswer: {answer}"
+    audio_file = speak_with_edge_tts(
+        audio_text,
+        voice=voice,
+        file_format=st.session_state['audio_format']
+    )
+    return md_file, audio_file
 
 # ─────────────────────────────────────────────────────────
-# 5. RESEARCH / ARXIV FUNCTIONS
+# 3. PAPER PARSING & DISPLAY
 # ─────────────────────────────────────────────────────────
 
 def parse_arxiv_refs(ref_text: str):
     """
-    📜 Given a multi-line markdown with Arxiv references,
-    parse them into a list of dicts: {date, title, url, authors, summary}.
+    Given a multi-line markdown with arxiv references, parse them into
+    a list of dicts: {date, title, url, authors, summary, ...}.
     """
     if not ref_text:
         return []
+
     results = []
     current_paper = {}
     lines = ref_text.split('\n')
@@ -501,9 +349,10 @@ def parse_arxiv_refs(ref_text: str):
                     'download_base64': '',
                 }
             except Exception as e:
-                st.warning(f"⚠️ Error parsing paper header: {str(e)}")
+                st.warning(f"Error parsing paper header: {str(e)}")
                 current_paper = {}
                 continue
+        
         elif current_paper:
             # If authors not set, fill it; otherwise, fill summary
             if not current_paper['authors']:
@@ -520,85 +369,197 @@ def parse_arxiv_refs(ref_text: str):
     return results[:20]
 
 def create_paper_links_md(papers):
-    """
-    🔗 Create a minimal .md content linking to each paper's Arxiv URL.
-    """
+    """Creates a minimal .md content linking to each paper's arxiv URL."""
     lines = ["# Paper Links\n"]
     for i, p in enumerate(papers, start=1):
         lines.append(f"{i}. **{p['title']}** — [Arxiv]({p['url']})")
     return "\n".join(lines)
 
-async def create_paper_audio_files(papers, input_question):
+def create_paper_audio_files(papers, input_question):
     """
-    🎧 For each paper, generate TTS audio summary and store the path in `paper['full_audio']`.
-    Also creates a base64 download link in `paper['download_base64']`.
+    For each paper, generate TTS audio summary, store the path in `paper['full_audio']`,
+    and also store a base64 link for stable downloading.
     """
     for paper in papers:
         try:
             audio_text = f"{paper['title']} by {paper['authors']}. {paper['summary']}"
             audio_text = clean_for_speech(audio_text)
             file_format = st.session_state['audio_format']
-            audio_file, _ = await async_edge_tts_generate(
+            audio_file = speak_with_edge_tts(
                 audio_text, 
                 voice=st.session_state['tts_voice'], 
                 file_format=file_format
             )
             paper['full_audio'] = audio_file
-            
+
             if audio_file:
-                # Convert to base64 link
-                ext = file_format
-                download_link = create_download_link_with_cache(audio_file, file_type=ext)
-                paper['download_base64'] = download_link
+                with open(audio_file, "rb") as af:
+                    b64_data = base64.b64encode(af.read()).decode()
+                download_filename = os.path.basename(audio_file)
+                mime_type = "mpeg" if file_format == "mp3" else "wav"
+                paper['download_base64'] = (
+                    f'<a href="data:audio/{mime_type};base64,{b64_data}" '
+                    f'download="{download_filename}">🎵 Download {download_filename}</a>'
+                )
 
         except Exception as e:
-            st.warning(f"⚠️ Error processing paper {paper['title']}: {str(e)}")
+            st.warning(f"Error processing paper {paper['title']}: {str(e)}")
             paper['full_audio'] = None
             paper['download_base64'] = ''
 
-def display_papers(papers, marquee_settings):
+            
+def display_file_history_in_sidebar():
     """
-    📑 Display paper info in the main area with marquee + expanders + audio.
+    Shows a history of files grouped by query, with lazy loading of audio and content.
     """
-    st.write("## 🔎 Research Papers")
+    st.sidebar.markdown("---")
+    st.sidebar.markdown("### 📂 File History")
+
+    # Gather all files
+    md_files = glob.glob("*.md")
+    mp3_files = glob.glob("*.mp3")
+    wav_files = glob.glob("*.wav")
+    all_files = md_files + mp3_files + wav_files
+
+    if not all_files:
+        st.sidebar.write("No files found.")
+        return
+
+    # Group files by their query prefix (timestamp_query)
+    grouped_files = {}
+    for f in all_files:
+        fname = os.path.basename(f)
+        prefix = '_'.join(fname.split('_')[:6])  # Get timestamp part
+        if prefix not in grouped_files:
+            grouped_files[prefix] = {'md': [], 'audio': [], 'loaded': False}
+        
+        ext = os.path.splitext(fname)[1].lower()
+        if ext == '.md':
+            grouped_files[prefix]['md'].append(f)
+        elif ext in ['.mp3', '.wav']:
+            grouped_files[prefix]['audio'].append(f)
+
+    # Sort groups by timestamp (newest first)
+    sorted_groups = sorted(grouped_files.items(), key=lambda x: x[0], reverse=True)
+
+    # 🗑⬇️ Sidebar delete all and zip all download
+    col1, col4 = st.sidebar.columns(2)
+    with col1:
+        if st.button("🗑 Delete All"):
+            for f in all_files:
+                os.remove(f)
+            st.session_state.should_rerun = True
+    with col4:
+        if st.button("⬇️ Zip All"):
+            zip_name = create_zip_of_files(md_files, mp3_files, wav_files, 
+                                         st.session_state.get('last_query', ''))
+            if zip_name:
+                st.sidebar.markdown(get_download_link(zip_name, "zip"), 
+                                  unsafe_allow_html=True)
+
+    # Display grouped files
+    for prefix, files in sorted_groups:
+        # Get a preview of content from first MD file
+        preview = ""
+        if files['md']:
+            with open(files['md'][0], "r", encoding="utf-8") as f:
+                preview = f.read(200).replace("\n", " ")
+                if len(preview) > 200:
+                    preview += "..."
+
+        # Create unique key for this group
+        group_key = f"group_{prefix}"
+        if group_key not in st.session_state:
+            st.session_state[group_key] = False
+
+        # Display group expander
+        with st.sidebar.expander(f"📑 Query Group: {prefix}"):
+            st.write("**Preview:**")
+            st.write(preview)
+            
+            # Load full content button
+            if st.button("📖 View Full Content", key=f"btn_{prefix}"):
+                st.session_state[group_key] = True
+
+            # Only show full content and audio if button was clicked
+            if st.session_state[group_key]:
+                # Display markdown files
+                for md_file in files['md']:
+                    with open(md_file, "r", encoding="utf-8") as f:
+                        content = f.read()
+                    st.markdown("**Full Content:**")
+                    st.markdown(content)
+                    st.markdown(get_download_link(md_file, file_type="md"), 
+                              unsafe_allow_html=True)
+
+                # Display audio files
+                usePlaySidebar=False
+                if usePlaySidebar:
+                    for audio_file in files['audio']:
+                        ext = os.path.splitext(audio_file)[1].replace('.', '')
+                        st.audio(audio_file)
+                        st.markdown(get_download_link(audio_file, file_type=ext), 
+                                  unsafe_allow_html=True)
+
+def display_papers(papers, marquee_settings):
+    """Display paper info with both abs and PDF links."""
+    st.write("## Research Papers")
     for i, paper in enumerate(papers, start=1):
-        marquee_text = f"📄 {paper['title']} | 👤 {paper['authors'][:120]} | 📝 {paper['summary'][:200]}"
+        marquee_text = f"📄 {paper['title']} | 👤 {paper['authors'][:120]}"
         display_marquee(marquee_text, marquee_settings, key_suffix=f"paper_{i}")
         
         with st.expander(f"{i}. 📄 {paper['title']}", expanded=True):
-            st.markdown(f"**{paper['date']} | {paper['title']}** — [Arxiv Link]({paper['url']})")
+            # Create PDF link by replacing 'abs' with 'pdf' in arxiv URL
+            pdf_url = paper['url'].replace('/abs/', '/pdf/')
+            st.markdown(f"""
+                **{paper['date']} | {paper['title']}**  
+                📄 [Abstract]({paper['url']}) | 📑 [PDF]({pdf_url})
+            """)
             st.markdown(f"*Authors:* {paper['authors']}")
             st.markdown(paper['summary'])
             if paper.get('full_audio'):
-                st.write("📚 **Paper Audio**")
+                st.write("📚 Paper Audio")
                 st.audio(paper['full_audio'])
                 if paper['download_base64']:
                     st.markdown(paper['download_base64'], unsafe_allow_html=True)
 
 def display_papers_in_sidebar(papers):
-    """
-    🔎 Mirrors the paper listing in the sidebar with expanders, audio, etc.
-    """
+    """Mirrors the paper listing in sidebar with lazy loading."""
     st.sidebar.title("🎶 Papers & Audio")
     for i, paper in enumerate(papers, start=1):
+        paper_key = f"paper_{paper['url']}"
+        if paper_key not in st.session_state:
+            st.session_state[paper_key] = False
+
         with st.sidebar.expander(f"{i}. {paper['title']}"):
-            st.markdown(f"**Arxiv:** [Link]({paper['url']})")
-            if paper['full_audio']:
+            # Create PDF link
+            pdf_url = paper['url'].replace('/abs/', '/pdf/')
+            st.markdown(f"📄 [Abstract]({paper['url']}) | 📑 [PDF]({pdf_url})")
+            
+            # Preview of authors and summary
+            st.markdown(f"**Authors:** {paper['authors'][:100]}...")
+            if paper['summary']:
+                st.markdown(f"**Summary:** {paper['summary'][:200]}...")
+            
+            # Load audio button
+            if paper['full_audio'] and st.button("🎵 Load Audio", 
+                                               key=f"btn_{paper_key}"):
+                st.session_state[paper_key] = True
+            
+            # Show audio player and download only if requested
+            if st.session_state[paper_key] and paper['full_audio']:
                 st.audio(paper['full_audio'])
                 if paper['download_base64']:
                     st.markdown(paper['download_base64'], unsafe_allow_html=True)
-            st.markdown(f"**Authors:** {paper['authors']}")
-            if paper['summary']:
-                st.markdown(f"**Summary:** {paper['summary'][:300]}...")
-
+                    
 # ─────────────────────────────────────────────────────────
-# 6. ZIP FUNCTION
+# 4. ZIP FUNCTION
 # ─────────────────────────────────────────────────────────
 
 def create_zip_of_files(md_files, mp3_files, wav_files, input_question):
     """
-    📦 Zip up all relevant files, generating a short name from high-info terms.
-    Returns the zip filename if created, else None.
+    Zip up all relevant files, limiting the final zip name to ~20 chars
+    to avoid overly long base64 strings. 
     """
     md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
     all_files = md_files + mp3_files + wav_files
@@ -608,7 +569,7 @@ def create_zip_of_files(md_files, mp3_files, wav_files, input_question):
     all_content = []
     for f in all_files:
         if f.endswith('.md'):
-            with open(f, "r", encoding='utf-8') as file:
+            with open(f, 'r', encoding='utf-8') as file:
                 all_content.append(file.read())
         elif f.endswith('.mp3') or f.endswith('.wav'):
             basename = os.path.splitext(os.path.basename(f))[0]
@@ -629,60 +590,98 @@ def create_zip_of_files(md_files, mp3_files, wav_files, input_question):
     return short_zip_name
 
 # ─────────────────────────────────────────────────────────
-# 7. MAIN AI LOGIC: LOOKUP & TAB HANDLERS
+# 5. MAIN LOGIC: AI LOOKUP & VOICE INPUT
 # ─────────────────────────────────────────────────────────
 
-def perform_ai_lookup(
-    q,
-    vocal_summary=True,
-    extended_refs=False,
-    titles_summary=True,
-    full_audio=False
-):
-    """
-    🔮 Main routine that uses Anthropic (Claude) + optional Gradio ArXiv RAG pipeline.
-    Currently demonstrates calling Anthropic and returning the text.
-    """
-    with PerformanceTimer("ai_lookup"):
-        start = time.time()
-        
-        # ▶ Example call to Anthropic (Claude)
-        client = anthropic.Anthropic(api_key=anthropic_key)
-        user_input = q
-        
-        # Here we do a minimal prompt, just to show the call
-        # (You can enhance your prompt engineering as needed)
-        response = client.completions.create(
-            model="claude-2",
-            max_tokens_to_sample=512,
-            prompt=f"{anthropic.HUMAN_PROMPT} {user_input}{anthropic.AI_PROMPT}"
-        )
-        
-        result_text = response.completion.strip()
-        
-        # ▶ Print and store
-        st.write("### Claude's reply 🧠:")
-        st.markdown(result_text)
-        
-        # ▶ We'll add to the chat history
-        st.session_state.chat_history.append({"user": q, "claude": result_text})
-        
-        # ▶ Return final text
-        end = time.time()
-        st.write(f"**Elapsed:** {end - start:.2f}s")
-        
-    return result_text
-
-async def process_voice_input(text):
-    """
-    🎤 When user sends a voice query, we run the AI lookup + Q/A with audio.
-    Then we store the resulting markdown & audio in session or disk.
-    """
+def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, 
+                     titles_summary=True, full_audio=False):
+    """Main routine that uses Anthropic (Claude) + Gradio ArXiv RAG pipeline."""
+    start = time.time()
+    ai_constitution = """
+    You are a talented AI coder and songwriter...
+    """
+
+    # --- 1) Claude API
+    client = anthropic.Anthropic(api_key=anthropic_key)
+    user_input = q
+    response = client.messages.create(
+        model="claude-3-sonnet-20240229",
+        max_tokens=1000,
+        messages=[
+            {"role": "user", "content": user_input}
+        ])
+    st.write("Claude's reply 🧠:")
+    st.markdown(response.content[0].text)
+
+    # Save & produce audio
+    result = response.content[0].text
+    create_file(q, result) 
+    md_file, audio_file = save_qa_with_audio(q, result)
+    st.subheader("📝 Main Response Audio")
+    play_and_download_audio(audio_file, st.session_state['audio_format'])
+
+    # --- 2) Arxiv RAG
+    #st.write("Arxiv's AI this Evening is Mixtral 8x7B...")
+    st.write('Running Arxiv RAG with Claude inputs.')
+    client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
+    refs = client.predict(
+        q, 
+        10, 
+        "Semantic Search", 
+        "mistralai/Mixtral-8x7B-Instruct-v0.1",
+        api_name="/update_with_rag_md"
+    )[0]
+
+    #r2 = client.predict(
+    #    q, 
+    #    "mistralai/Mixtral-8x7B-Instruct-v0.1", 
+    #    True, 
+    #    api_name="/ask_llm"
+    #)
+
+    # --- 3) Claude API with arxiv list of papers to app.py
+    client = anthropic.Anthropic(api_key=anthropic_key)
+    user_input = q + '\n\n' + 'Use the paper list below to answer the question thinking through step by step how to create a streamlit app.py and requirements.txt for the solution that answers the questions with a working app to demonstrate.'+ '\n\n'
+    response = client.messages.create(
+        model="claude-3-sonnet-20240229",
+        max_tokens=1000,
+        messages=[
+            {"role": "user", "content": user_input}
+        ])
+    r2 = response.content[0].text
+    st.write("Claude's reply 🧠:")
+    st.markdown(r2)
+    
+    #result = f"### 🔎 {q}\n\n{r2}\n\n{refs}"
+    result = f"🔎 {r2}\n\n{refs}"
+    md_file, audio_file = save_qa_with_audio(q, result)
+    st.subheader("📝 Main Response Audio")
+    play_and_download_audio(audio_file, st.session_state['audio_format'])
+
+    # --- 3) Parse + handle papers
+    papers = parse_arxiv_refs(refs)
+    if papers:
+        # Create minimal links page first
+        paper_links = create_paper_links_md(papers)
+        links_file = create_file(q, paper_links, "md")
+        st.markdown(paper_links)
+
+        # Then create audio for each paper
+        create_paper_audio_files(papers, input_question=q)
+        display_papers(papers, get_marquee_settings())
+        display_papers_in_sidebar(papers)
+    else:
+        st.warning("No papers found in the response.")
+
+    elapsed = time.time() - start
+    st.write(f"**Total Elapsed:** {elapsed:.2f} s")
+    return result
+
+def process_voice_input(text):
+    """When user sends voice query, we run the AI lookup + Q&A with audio."""
     if not text:
         return
     st.subheader("🔍 Search Results")
-    
-    # ▶ Call AI
     result = perform_ai_lookup(
         text, 
         vocal_summary=True,
@@ -690,98 +689,25 @@ async def process_voice_input(text):
         titles_summary=True,
         full_audio=True
     )
-    
-    # ▶ Save Q&A as Markdown + audio (async)
-    md_file, audio_file, md_time, audio_time = await async_save_qa_with_audio(text, result)
-
+    md_file, audio_file = save_qa_with_audio(text, result)
     st.subheader("📝 Generated Files")
-    st.write(f"**Markdown:** {md_file} (saved in {md_time:.2f}s)")
-    if audio_file:
-        st.write(f"**Audio:** {audio_file} (generated in {audio_time:.2f}s)")
-        st.audio(audio_file)
-        dl_link = create_download_link_with_cache(audio_file, file_type=st.session_state['audio_format'])
-        st.markdown(dl_link, unsafe_allow_html=True)
-
-def display_voice_tab():
-    """
-    🎙️ Display the voice input tab with TTS settings and real-time usage.
-    """
-    st.subheader("🎤 Voice Input")
-    
-    # ▶ Voice Settings
-    st.markdown("### 🎤 Voice Settings")
-    caption_female = 'Top: 🌸 **Aria** – 🎶 **Jenny** – 🌺 **Sonia** – 🌌 **Natasha** – 🌷 **Clara**'
-    caption_male   = 'Bottom: 🌟 **Guy** – 🛠️ **Ryan** – 🎻 **William** – 🌟 **Liam**'
-    
-    # Optionally, replace with your own local image or comment out
-    # st.sidebar.image('Group Picture - Voices.png', caption=caption_female + ' | ' + caption_male)
-    
-    st.sidebar.markdown("""
-    # 🎙️ Voice Character Agent Selector 🎭
-    *Female Voices*:
-    - 🌸 **Aria** – Elegant, creative storytelling  
-    - 🎶 **Jenny** – Friendly, conversational  
-    - 🌺 **Sonia** – Bold, confident  
-    - 🌌 **Natasha** – Sophisticated, mysterious  
-    - 🌷 **Clara** – Cheerful, empathetic  
-
-    *Male Voices*:
-    - 🌟 **Guy** – Authoritative, versatile  
-    - 🛠️ **Ryan** – Approachable, casual  
-    - 🎻 **William** – Classic, scholarly  
-    - 🌟 **Liam** – Energetic, engaging
-    """)
-    
-    selected_voice = st.selectbox(
-        "👄 Select TTS Voice:",
-        options=EDGE_TTS_VOICES,
-        index=EDGE_TTS_VOICES.index(st.session_state['tts_voice'])
-    )
-    
-    # ▶ Audio Format
-    st.markdown("### 🔊 Audio Format")
-    selected_format = st.radio(
-        "Choose Audio Format:",
-        options=["MP3", "WAV"],
-        index=0
-    )
-
-    # ▶ Update session state if changed
-    if selected_voice != st.session_state['tts_voice']:
-        st.session_state['tts_voice'] = selected_voice
-        st.experimental_rerun()
-    if selected_format.lower() != st.session_state['audio_format']:
-        st.session_state['audio_format'] = selected_format.lower()
-        st.experimental_rerun()
-
-    # ▶ Text Input
-    user_text = st.text_area("💬 Message:", height=100)
-    user_text = user_text.strip().replace('\n', ' ')
-
-    # ▶ Send Button
-    if st.button("📨 Send"):
-        # Run our process_voice_input as an async function
-        asyncio.run(process_voice_input(user_text))
-
-    # ▶ Chat History
-    st.subheader("📜 Chat History")
-    for c in st.session_state.chat_history:
-        st.write("**You:**", c["user"])
-        st.write("**Response:**", c["claude"])
+    st.write(f"Markdown: {md_file}")
+    st.write(f"Audio: {audio_file}")
+    play_and_download_audio(audio_file, st.session_state['audio_format'])
 
 # ─────────────────────────────────────────────────────────
-# FILE HISTORY SIDEBAR
+# 6. FILE HISTORY SIDEBAR
 # ─────────────────────────────────────────────────────────
 
 def display_file_history_in_sidebar():
     """
-    📂 Shows a history of local .md, .mp3, .wav files (newest first),
-    with quick icons and optional download links.
+    Shows a history of each local .md, .mp3, .wav file in descending
+    order of modification time, with quick icons and optional download links.
     """
     st.sidebar.markdown("---")
     st.sidebar.markdown("### 📂 File History")
 
-    # ▶ Gather all files
+    # Gather all files
     md_files = glob.glob("*.md")
     mp3_files = glob.glob("*.mp3")
     wav_files = glob.glob("*.wav")
@@ -791,7 +717,24 @@ def display_file_history_in_sidebar():
         st.sidebar.write("No files found.")
         return
 
-    # ▶ Sort newest first
+    # 🗑⬇️ Sidebar delete all and zip all download
+    col1, col4 = st.sidebar.columns(2)
+    with col1:
+        if st.button("🗑 Delete All"):
+            for f in all_md:
+                os.remove(f)
+            for f in all_mp3:
+                os.remove(f)
+            for f in all_wav:
+                os.remove(f)
+            st.session_state.should_rerun = True
+    with col4:
+        if st.button("⬇️ Zip All"):
+            zip_name = create_zip_of_files(md_files, mp3_files, wav_files, st.session_state.get('last_query', ''))
+            if zip_name:
+                st.sidebar.markdown(get_download_link(zip_name, "zip"), unsafe_allow_html=True)
+    
+    # Sort newest first
     all_files = sorted(all_files, key=os.path.getmtime, reverse=True)
 
     for f in all_files:
@@ -808,44 +751,39 @@ def display_file_history_in_sidebar():
                 if len(snippet) == 200:
                     snippet += "..."
                 st.write(snippet)
-                dl_link = create_download_link_with_cache(f, file_type="md")
-                st.markdown(dl_link, unsafe_allow_html=True)
+                st.markdown(get_download_link(f, file_type="md"), unsafe_allow_html=True)
             elif ext in ["mp3","wav"]:
                 st.audio(f)
-                dl_link = create_download_link_with_cache(f, file_type=ext)
-                st.markdown(dl_link, unsafe_allow_html=True)
+                st.markdown(get_download_link(f, file_type=ext), unsafe_allow_html=True)
             else:
-                dl_link = create_download_link_with_cache(f)
-                st.markdown(dl_link, unsafe_allow_html=True)
+                st.markdown(get_download_link(f), unsafe_allow_html=True)
 
 # ─────────────────────────────────────────────────────────
-# MAIN APP
+# 7. MAIN APP
 # ─────────────────────────────────────────────────────────
 
 def main():
-    # ▶ 1) Setup marquee UI in the sidebar
+    # 1) Setup marquee UI in the sidebar
     update_marquee_settings_ui()
     marquee_settings = get_marquee_settings()
 
-    # ▶ 2) Display the marquee welcome
-    display_marquee(
-        st.session_state['marquee_content'], 
-        {**marquee_settings, "font-size": "28px", "lineHeight": "50px"},
-        key_suffix="welcome"
-    )
+    # 2) Display the marquee welcome
+    display_marquee(st.session_state['marquee_content'], 
+                    {**marquee_settings, "font-size": "28px", "lineHeight": "50px"},
+                    key_suffix="welcome")
 
-    # ▶ 3) Main action tabs
+    # 3) Main action tabs
     tab_main = st.radio("Action:", ["🎤 Voice", "📸 Media", "🔍 ArXiv", "📝 Editor"], 
                         horizontal=True)
 
-    # ▶ 4) Show or hide custom component (optional example)
+    # Example custom component usage
     mycomponent = components.declare_component("mycomponent", path="mycomponent")
-    val = mycomponent(my_input_value="Hello from MyComponent")
+    val = mycomponent(my_input_value="Hello")
 
     if val:
         val_stripped = val.replace('\\n', ' ')
         edited_input = st.text_area("✏️ Edit Input:", value=val_stripped, height=100)
-        run_option = st.selectbox("Model:", ["Arxiv", "Other (demo)"])
+        run_option = st.selectbox("Model:", ["Arxiv"])
         col1, col2 = st.columns(2)
         with col1:
             autorun = st.checkbox("⚙ AutoRun", value=True)
@@ -871,7 +809,7 @@ def main():
                                   extended_refs=False, 
                                   titles_summary=True, 
                                   full_audio=full_audio)
-
+    
     # ─────────────────────────────────────────────────────────
     # TAB: ArXiv
     # ─────────────────────────────────────────────────────────
@@ -888,11 +826,8 @@ def main():
         
         if q and st.button("🔍Run"):
             st.session_state.last_query = q
-            result = perform_ai_lookup(q, 
-                                       vocal_summary=vocal_summary, 
-                                       extended_refs=extended_refs, 
-                                       titles_summary=titles_summary, 
-                                       full_audio=full_audio)
+            result = perform_ai_lookup(q, vocal_summary=vocal_summary, extended_refs=extended_refs, 
+                                       titles_summary=titles_summary, full_audio=full_audio)
             if full_transcript:
                 create_file(q, result, "md")
 
@@ -900,16 +835,52 @@ def main():
     # TAB: Voice
     # ─────────────────────────────────────────────────────────
     elif tab_main == "🎤 Voice":
-        display_voice_tab()
+        st.subheader("🎤 Voice Input")
+        
+        st.markdown("### 🎤 Voice Settings")
+        selected_voice = st.selectbox(
+            "Select TTS Voice:",
+            options=EDGE_TTS_VOICES,
+            index=EDGE_TTS_VOICES.index(st.session_state['tts_voice'])
+        )
+        
+        st.markdown("### 🔊 Audio Format")
+        selected_format = st.radio(
+            "Choose Audio Format:",
+            options=["MP3", "WAV"],
+            index=0
+        )
+
+        # Update session state if voice/format changes
+        if selected_voice != st.session_state['tts_voice']:
+            st.session_state['tts_voice'] = selected_voice
+            st.rerun()
+        if selected_format.lower() != st.session_state['audio_format']:
+            st.session_state['audio_format'] = selected_format.lower()
+            st.rerun()
+
+        # Input text
+        user_text = st.text_area("💬 Message:", height=100)
+        user_text = user_text.strip().replace('\n', ' ')
+
+        if st.button("📨 Send"):
+            process_voice_input(user_text)
+
+        st.subheader("📜 Chat History")
+        for c in st.session_state.chat_history:
+            st.write("**You:**", c["user"])
+            st.write("**Response:**", c["claude"])
 
     # ─────────────────────────────────────────────────────────
     # TAB: Media
     # ─────────────────────────────────────────────────────────
     elif tab_main == "📸 Media":
         st.header("📸 Media Gallery")
+
+        # By default, show audio first
         tabs = st.tabs(["🎵 Audio", "🖼 Images", "🎥 Video"])
         
-        # ▶ AUDIO sub-tab
+        # AUDIO sub-tab
         with tabs[0]:
             st.subheader("🎵 Audio Files")
             audio_files = glob.glob("*.mp3") + glob.glob("*.wav")
@@ -918,12 +889,12 @@ def main():
                     with st.expander(os.path.basename(a)):
                         st.audio(a)
                         ext = os.path.splitext(a)[1].replace('.', '')
-                        dl_link = create_download_link_with_cache(a, file_type=ext)
+                        dl_link = get_download_link(a, file_type=ext)
                         st.markdown(dl_link, unsafe_allow_html=True)
             else:
                 st.write("No audio files found.")
         
-        # ▶ IMAGES sub-tab
+        # IMAGES sub-tab
         with tabs[1]:
             st.subheader("🖼 Image Files")
             imgs = glob.glob("*.png") + glob.glob("*.jpg") + glob.glob("*.jpeg")
@@ -936,7 +907,7 @@ def main():
             else:
                 st.write("No images found.")
         
-        # ▶ VIDEO sub-tab
+        # VIDEO sub-tab
         with tabs[2]:
             st.subheader("🎥 Video Files")
             vids = glob.glob("*.mp4") + glob.glob("*.mov") + glob.glob("*.avi")
@@ -951,16 +922,14 @@ def main():
     # TAB: Editor
     # ─────────────────────────────────────────────────────────
     elif tab_main == "📝 Editor":
-        st.write("### 📝 File Editor (Minimal Demo)")
-        st.write("Select or create a file to edit. More advanced features can be added as needed.")
+        st.write("Select or create a file to edit. (Currently minimal demo)")
 
     # ─────────────────────────────────────────────────────────
-    # SIDEBAR: FILE HISTORY + PERFORMANCE METRICS
+    # SIDEBAR: FILE HISTORY
     # ─────────────────────────────────────────────────────────
     display_file_history_in_sidebar()
-    log_performance_metrics()
 
-    # ▶ Some light CSS styling
+    # Some light CSS styling
     st.markdown("""
     <style>
         .main { background: linear-gradient(to right, #1a1a1a, #2d2d2d); color: #fff; }
@@ -969,14 +938,10 @@ def main():
     </style>
     """, unsafe_allow_html=True)
 
-    # ▶ Rerun if needed
+    # Rerun if needed
     if st.session_state.should_rerun:
         st.session_state.should_rerun = False
-        st.experimental_rerun()
-
-# ─────────────────────────────────────────────────────────
-# 8. RUN APP
-# ─────────────────────────────────────────────────────────
+        st.rerun()
 
 if __name__ == "__main__":
     main()