Update app.py

app.py

@@ -19,11 +19,8 @@ import extra_streamlit_components as stx
 from streamlit.runtime.scriptrunner import get_script_run_ctx
 import asyncio
 import edge_tts
-
-# Imports section (add streamlit-marquee)
 from streamlit_marquee import streamlit_marquee
 
-
 # 🎯 1. Core Configuration & Setup
 st.set_page_config(
     page_title="🚲TalkingAIResearcher🏆",
@@ -38,40 +35,6 @@ st.set_page_config(
 )
 load_dotenv()
 
-
-def display_marquee_controls():
-    st.sidebar.markdown("### 🎯 Marquee Settings")
-    cols = st.sidebar.columns(2)
-    with cols[0]:
-        bg_color = st.color_picker("🎨 Background", "#1E1E1E", key="bg_color_picker")
-        text_color = st.color_picker("✍️ Text", "#FFFFFF", key="text_color_picker")
-    with cols[1]:
-        font_size = st.slider("📏 Size", 10, 24, 14, key="font_size_slider")
-        duration = st.slider("⏱️ Speed", 1, 20, 10, key="duration_slider")
-    
-    return {
-        "background": bg_color,
-        "color": text_color,
-        "font-size": f"{font_size}px",
-        "animationDuration": f"{duration}s",
-        "width": "100%",
-        "lineHeight": "35px"
-    }
-
-
-def display_marquee_controls_papers():
-    return {
-        "background": "#1E1E1E",
-        "color": "#1E1E1E",
-        "font-size": f"24px",
-        "animationDuration": f"20s",
-        "width": "100%",
-        "lineHeight": "35px"
-    }
-
-# Add global marquee settings 
-marquee_settings = display_marquee_controls()
-
 # Add available English voices for Edge TTS
 EDGE_TTS_VOICES = [
     "en-US-AriaNeural",  # Default voice
@@ -87,26 +50,9 @@ EDGE_TTS_VOICES = [
 
 # Initialize session state variables
 if 'tts_voice' not in st.session_state:
-    st.session_state['tts_voice'] = EDGE_TTS_VOICES[0]  # Default voice
+    st.session_state['tts_voice'] = EDGE_TTS_VOICES[0]
 if 'audio_format' not in st.session_state:
-    st.session_state['audio_format'] = 'mp3'  # 🆕 Default audio format
-
-# 🔑 2. API Setup & Clients
-openai_api_key = os.getenv('OPENAI_API_KEY', "")
-anthropic_key = os.getenv('ANTHROPIC_API_KEY_3', "")
-xai_key = os.getenv('xai',"")
-if 'OPENAI_API_KEY' in st.secrets:
-    openai_api_key = st.secrets['OPENAI_API_KEY']
-if 'ANTHROPIC_API_KEY' in st.secrets:
-    anthropic_key = st.secrets["ANTHROPIC_API_KEY"]
-
-openai.api_key = openai_api_key
-claude_client = anthropic.Anthropic(api_key=anthropic_key)
-openai_client = OpenAI(api_key=openai.api_key, organization=os.getenv('OPENAI_ORG_ID'))
-HF_KEY = os.getenv('HF_KEY')
-API_URL = os.getenv('API_URL')
-
-# 📝 3. Session State Management
+    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:
@@ -130,109 +76,115 @@ if 'should_rerun' not in st.session_state:
 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'] = ""  # 🆕 Store the last query for zip naming
+    st.session_state['last_query'] = ""
+if 'marquee_content' not in st.session_state:
+    st.session_state['marquee_content'] = "🚀 Welcome to TalkingAIResearcher | 🤖 Your Research Assistant"
 
-# 🎨 4. Custom CSS
-st.markdown("""
-<style>
-    .main { background: linear-gradient(to right, #1a1a1a, #2d2d2d); color: #fff; }
-    .stMarkdown { font-family: 'Helvetica Neue', sans-serif; }
-    .stButton>button {
-        margin-right: 0.5rem;
-    }
-</style>
-""", unsafe_allow_html=True)
+# 🔑 2. API Setup & Clients
+openai_api_key = os.getenv('OPENAI_API_KEY', "")
+anthropic_key = os.getenv('ANTHROPIC_API_KEY_3', "")
+xai_key = os.getenv('xai',"")
+if 'OPENAI_API_KEY' in st.secrets:
+    openai_api_key = st.secrets['OPENAI_API_KEY']
+if 'ANTHROPIC_API_KEY' in st.secrets:
+    anthropic_key = st.secrets["ANTHROPIC_API_KEY"]
 
+openai.api_key = openai_api_key
+claude_client = anthropic.Anthropic(api_key=anthropic_key)
+openai_client = OpenAI(api_key=openai.api_key, organization=os.getenv('OPENAI_ORG_ID'))
+HF_KEY = os.getenv('HF_KEY')
+API_URL = os.getenv('API_URL')
+
+# Constants
 FILE_EMOJIS = {
     "md": "📝",
     "mp3": "🎵",
-    "wav": "🔊"  # 🆕 Add emoji for WAV
+    "wav": "🔊"
 }
 
-# 🧠 5. High-Information Content Extraction
-def get_high_info_terms(text: str, top_n=10) -> list:
-    """Extract high-information terms from text, including key phrases."""
-    stop_words = set([
-        'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with',
-        'by', 'from', 'up', 'about', 'into', 'over', 'after', 'is', 'are', 'was', 'were',
-        'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would',
-        'should', 'could', 'might', 'must', 'shall', 'can', 'may', 'this', 'that', 'these',
-        'those', 'i', 'you', 'he', 'she', 'it', 'we', 'they', 'what', 'which', 'who',
-        'when', 'where', 'why', 'how', 'all', 'any', 'both', 'each', 'few', 'more', 'most',
-        'other', 'some', 'such', 'than', 'too', 'very', 'just', 'there'
-    ])
+# Marquee Functions
+def get_marquee_settings():
+    """Get global marquee settings from sidebar controls"""
+    st.sidebar.markdown("### 🎯 Marquee Settings")
+    cols = st.sidebar.columns(2)
+    with cols[0]:
+        bg_color = st.color_picker("🎨 Background", "#1E1E1E", key="bg_color_picker")
+        text_color = st.color_picker("✍️ Text", "#FFFFFF", key="text_color_picker")
+    with cols[1]:
+        font_size = st.slider("📏 Size", 10, 24, 14, key="font_size_slider")
+        duration = st.slider("⏱️ Speed", 1, 20, 10, key="duration_slider")
+    
+    return {
+        "background": bg_color,
+        "color": text_color,
+        "font-size": f"{font_size}px",
+        "animationDuration": f"{duration}s",
+        "width": "100%",
+        "lineHeight": "35px"
+    }
+
+def display_marquee(text, settings, key_suffix=""):
+    """Display marquee with given text and settings"""
+    truncated_text = text[:280] + "..." if len(text) > 280 else text
+    streamlit_marquee(
+        content=truncated_text,
+        **settings,
+        key=f"marquee_{key_suffix}"
+    )
+    st.write("")
 
-    key_phrases = [
-        'artificial intelligence', 'machine learning', 'deep learning', 'neural network',
-        'personal assistant', 'natural language', 'computer vision', 'data science',
-        'reinforcement learning', 'knowledge graph', 'semantic search', 'time series',
-        'large language model', 'transformer model', 'attention mechanism',
-        'autonomous system', 'edge computing', 'quantum computing', 'blockchain technology',
-        'cognitive science', 'human computer', 'decision making', 'arxiv search',
-        'research paper', 'scientific study', 'empirical analysis'
-    ]
+def process_paper_content(paper):
+    """Process paper content for marquee and audio"""
+    marquee_text = f"📄 {paper['title']} | 👤 {paper['authors'][:100]} | 📝 {paper['summary'][:100]}"
+    audio_text = f"{paper['title']} by {paper['authors']}. {paper['summary']}"
+    return marquee_text, audio_text
 
-    # Extract bi-grams and uni-grams
+# Text Processing Functions
+def get_high_info_terms(text: str, top_n=10) -> list:
+    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:])]
     combined = words + bi_grams
-
-    # Filter out stop words and short words
-    filtered = [
-        term for term in combined
-        if term not in stop_words
-        and len(term.split()) <= 2  # Limit to uni-grams and bi-grams
-        and any(c.isalpha() for c in term)
-    ]
-
-    # Count frequencies
+    filtered = [term for term in combined if term not in stop_words and len(term.split()) <= 2]
     counter = Counter(filtered)
-    most_common = [term for term, freq in counter.most_common(top_n)]
-    return most_common
+    return [term for term, freq in counter.most_common(top_n)]
 
 def clean_text_for_filename(text: str) -> str:
-    """Remove punctuation and short filler words, return a compact string."""
     text = text.lower()
     text = re.sub(r'[^\w\s-]', '', text)
     words = text.split()
-    stop_short = set(['the','and','for','with','this','that','from','just','very','then','been','only','also','about'])
-    filtered = [w for w in words if len(w)>3 and w not in stop_short]
+    stop_short = set(['the', 'and', 'for', 'with', 'this', 'that'])
+    filtered = [w for w in words if len(w) > 3 and w not in stop_short]
     return '_'.join(filtered)[:200]
 
-# 📁 6. File Operations
+def clean_for_speech(text: str) -> str:
+    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
+
+# File Operations
 def generate_filename(prompt, response, file_type="md"):
-    """
-    Generate filename with meaningful terms and short dense clips from prompt & response.
-    The filename should be about 150 chars total, include high-info terms, and a clipped snippet.
-    """
     prefix = datetime.now().strftime("%y%m_%H%M") + "_"
     combined = (prompt + " " + response).strip()
     info_terms = get_high_info_terms(combined, top_n=10)
-    
-    # Include a short snippet from prompt and response
     snippet = (prompt[:100] + " " + response[:100]).strip()
     snippet_cleaned = clean_text_for_filename(snippet)
-    
-    # Combine info terms and snippet
     name_parts = info_terms + [snippet_cleaned]
     full_name = '_'.join(name_parts)
-
-    # Trim to ~150 chars
     if len(full_name) > 150:
         full_name = full_name[:150]
-    
-    filename = f"{prefix}{full_name}.{file_type}"
-    return filename
+    return f"{prefix}{full_name}.{file_type}"
 
 def create_file(prompt, response, file_type="md"):
-    """Create file with intelligent naming"""
     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
 
 def get_download_link(file, file_type="zip"):
-    """Generate download link for file"""
     with open(file, "rb") as f:
         b64 = base64.b64encode(f.read()).decode()
     if file_type == "zip":
@@ -240,37 +192,14 @@ def get_download_link(file, file_type="zip"):
     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>'  # 🆕 WAV download link
+        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>'
 
-# 🔊 7. Audio Processing
-def clean_for_speech(text: str) -> str:
-    """Clean text for speech synthesis"""
-    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
-
-@st.cache_resource
-def speech_synthesis_html(result):
-    """Create HTML for speech synthesis"""
-    html_code = f"""
-    <html><body>
-    <script>
-    var msg = new SpeechSynthesisUtterance("{result.replace('"', '')}");
-    window.speechSynthesis.speak(msg);
-    </script>
-    </body></html>
-    """
-    components.html(html_code, height=0)
-
+# Audio Processing
 async def edge_tts_generate_audio(text, voice="en-US-AriaNeural", rate=0, pitch=0, file_format="mp3"):
-    """Generate audio using Edge TTS"""
     text = clean_for_speech(text)
     if not text.strip():
         return None
@@ -282,88 +211,16 @@ async def edge_tts_generate_audio(text, voice="en-US-AriaNeural", rate=0, pitch=
     return out_fn
 
 def speak_with_edge_tts(text, voice="en-US-AriaNeural", rate=0, pitch=0, file_format="mp3"):
-    """Wrapper for edge TTS generation"""
     return asyncio.run(edge_tts_generate_audio(text, voice, rate, pitch, file_format))
 
 def play_and_download_audio(file_path, file_type="mp3"):
-    """Play and provide download link for audio"""
     if file_path and os.path.exists(file_path):
-        if file_type == "mp3":
-            st.audio(file_path)
-        elif file_type == "wav":
-            st.audio(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)
 
-# 🎬 8. Media Processing
-def process_image(image_path, user_prompt):
-    """Process image with GPT-4V"""
-    with open(image_path, "rb") as imgf:
-        image_data = imgf.read()
-    b64img = base64.b64encode(image_data).decode("utf-8")
-    resp = openai_client.chat.completions.create(
-        model=st.session_state["openai_model"],
-        messages=[
-            {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": [
-                {"type": "text", "text": user_prompt},
-                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64img}"}}
-            ]}
-        ],
-        temperature=0.0,
-    )
-    return resp.choices[0].message.content
-
-def process_audio_file(audio_path):
-    """Process audio with Whisper"""
-    with open(audio_path, "rb") as f:
-        transcription = openai_client.audio.transcriptions.create(model="whisper-1", file=f)
-    st.session_state.messages.append({"role": "user", "content": transcription.text})
-    return transcription.text
-
-def process_video(video_path, seconds_per_frame=1):
-    """Extract frames from video"""
-    vid = cv2.VideoCapture(video_path)
-    total = int(vid.get(cv2.CAP_PROP_FRAME_COUNT))
-    fps = vid.get(cv2.CAP_PROP_FPS)
-    skip = int(fps*seconds_per_frame)
-    frames_b64 = []
-    for i in range(0, total, skip):
-        vid.set(cv2.CAP_PROP_POS_FRAMES, i)
-        ret, frame = vid.read()
-        if not ret: 
-            break
-        _, buf = cv2.imencode(".jpg", frame)
-        frames_b64.append(base64.b64encode(buf).decode("utf-8"))
-    vid.release()
-    return frames_b64
-
-def process_video_with_gpt(video_path, prompt):
-    """Analyze video frames with GPT-4V"""
-    frames = process_video(video_path)
-    resp = openai_client.chat.completions.create(
-        model=st.session_state["openai_model"],
-        messages=[
-            {"role":"system","content":"Analyze video frames."},
-            {"role":"user","content":[
-                {"type":"text","text":prompt},
-                *[{"type":"image_url","image_url":{"url":f"data:image/jpeg;base64,{fr}"}} for fr in frames]
-            ]}
-        ]
-    )
-    return resp.choices[0].message.content
-
-# 🤖 9. AI Model Integration
-
-def save_full_transcript(query, text):
-    """Save full transcript of Arxiv results as a file."""
-    create_file(query, text, "md")
-
+# Paper Processing Functions
 def parse_arxiv_refs(ref_text: str):
-    """
-    Parse papers by finding lines with two pipe characters as title lines.
-    Returns list of paper dictionaries with audio files.
-    """
     if not ref_text:
         return []
 
@@ -372,21 +229,16 @@ def parse_arxiv_refs(ref_text: str):
     lines = ref_text.split('\n')
     
     for i, line in enumerate(lines):
-        # Check if this is a title line (contains exactly 2 pipe characters)
         if line.count('|') == 2:
-            # If we have a previous paper, add it to results
             if current_paper:
                 results.append(current_paper)
-                if len(results) >= 20:  # Limit to 20 papers
+                if len(results) >= 20:
                     break
             
-            # Parse new paper header
             try:
-                # Remove ** and split by |
                 header_parts = line.strip('* ').split('|')
                 date = header_parts[0].strip()
                 title = header_parts[1].strip()
-                # Extract arXiv URL if present
                 url_match = re.search(r'(https://arxiv.org/\S+)', line)
                 url = url_match.group(1) if url_match else f"paper_{len(results)}"
                 
@@ -396,85 +248,61 @@ def parse_arxiv_refs(ref_text: str):
                     'url': url,
                     'authors': '',
                     'summary': '',
-                    'content_start': i + 1  # Track where content begins
+                    'content_start': i + 1
                 }
             except Exception as e:
                 st.warning(f"Error parsing paper header: {str(e)}")
                 current_paper = {}
                 continue
         
-        # If we have a current paper and this isn't a title line, add to content
         elif current_paper:
-            if not current_paper['authors']:  # First line after title is authors
+            if not current_paper['authors']:
                 current_paper['authors'] = line.strip('* ')
-            else:  # Rest is summary
+            else:
                 if current_paper['summary']:
                     current_paper['summary'] += ' ' + line.strip()
                 else:
                     current_paper['summary'] = line.strip()
     
-    # Don't forget the last paper
     if current_paper:
         results.append(current_paper)
     
-    return results[:20]  # Ensure we return maximum 20 papers
+    return results[:20]
 
 def create_paper_audio_files(papers, input_question):
-    """
-    Create audio files for each paper's content and add file paths to paper dict.
-    Also, display each audio as it's generated.
-    """
-    # Collect all content for combined summary
-    combined_titles = []
-
     for paper in papers:
         try:
-            # Generate audio for full content only
-            full_text = f"{paper['title']} by {paper['authors']}. {paper['summary']}"
-            full_text = clean_for_speech(full_text)
-            # Determine file format based on user selection
+            marquee_text, audio_text = process_paper_content(paper)
+            
+            audio_text = clean_for_speech(audio_text)
             file_format = st.session_state['audio_format']
-            full_file = speak_with_edge_tts(full_text, voice=st.session_state['tts_voice'], file_format=file_format)
-            paper['full_audio'] = full_file
-
-            # Display the audio immediately after generation
-            st.write(f"### {FILE_EMOJIS.get(file_format, '')} {os.path.basename(full_file)}")
-            play_and_download_audio(full_file, file_type=file_format)
+            audio_file = speak_with_edge_tts(audio_text, 
+                                           voice=st.session_state['tts_voice'], 
+                                           file_format=file_format)
+            paper['full_audio'] = audio_file
+            
+            st.write(f"### {FILE_EMOJIS.get(file_format, '')} {os.path.basename(audio_file)}")
+            play_and_download_audio(audio_file, file_type=file_format)
+            paper['marquee_text'] = marquee_text
             
-            combined_titles.append(paper['title'])
-        
         except Exception as e:
-            st.warning(f"Error generating audio for paper {paper['title']}: {str(e)}")
+            st.warning(f"Error processing paper {paper['title']}: {str(e)}")
             paper['full_audio'] = None
+            paper['marquee_text'] = None
 
-    # After all individual audios, create a combined summary audio
-    if combined_titles:
-        combined_text = f"Here are the titles of the papers related to your query: {'; '.join(combined_titles)}. Your original question was: {input_question}"
-        file_format = st.session_state['audio_format']
-        combined_file = speak_with_edge_tts(combined_text, voice=st.session_state['tts_voice'], file_format=file_format)
-        st.write(f"### {FILE_EMOJIS.get(file_format, '')} Combined Summary Audio")
-        play_and_download_audio(combined_file, file_type=file_format)
-        papers.append({'title': 'Combined Summary', 'full_audio': combined_file})
-
-
-
-def display_papers(papers):
-    """Display papers with their audio controls and marquee summaries."""
+def display_papers(papers, marquee_settings):
+    """Display papers with their audio controls and marquee summaries"""
     st.write("## Research Papers")
-    marquee_settings = display_marquee_controls_papers()
     
     papercount = 0
     for paper in papers:
-        papercount = papercount + 1
+        papercount += 1
         if papercount <= 20:
-            # Add marquee display
-            content = f"📄 {paper['title']} | 👤 {paper['authors']} | 📝 {paper['summary']}"
-            streamlit_marquee(
-                content=content,
-                **marquee_settings,
-                key=f"paper_{paper.get('id', random.randint(1000,9999))}"
-            )
-            st.write("")
+            # Display marquee if text exists
+            if paper.get('marquee_text'):
+                display_marquee(paper['marquee_text'], 
+                              marquee_settings,
+                              key_suffix=f"paper_{papercount}")
             
             with st.expander(f"{papercount}. 📄 {paper['title']}", expanded=True):
                 st.markdown(f"**{paper['date']} | {paper['title']} | ⬇️**")
@@ -487,9 +315,8 @@ def display_papers(papers):
                     if file_ext in ['mp3', 'wav']:
                         st.audio(paper['full_audio'])
 
-                        
 def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, 
-                     titles_summary=True, full_audio=False):
+                     titles_summary=True, full_audio=False, marquee_settings=None):
     """Perform Arxiv search with audio generation per paper."""
     start = time.time()
 
@@ -509,7 +336,10 @@ def perform_ai_lookup(q, vocal_summary=True, extended_refs=False,
     papers = parse_arxiv_refs(refs)
     if papers:
         create_paper_audio_files(papers, input_question=q)
-        display_papers(papers)
+        if marquee_settings:
+            display_papers(papers, marquee_settings)
+        else:
+            display_papers(papers, get_marquee_settings())
     else:
         st.warning("No papers found in the response.")
 
@@ -557,30 +387,44 @@ def process_with_claude(text):
         st.session_state.chat_history.append({"user":text,"claude":ans})
     return ans
 
-# 📂 10. File Management
+def load_files_for_sidebar():
+    """Load and group files for sidebar display based on first 9 characters of filename"""
+    md_files = glob.glob("*.md")
+    mp3_files = glob.glob("*.mp3")
+    wav_files = glob.glob("*.wav")
+
+    md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
+    all_files = md_files + mp3_files + wav_files
+
+    groups = defaultdict(list)
+    for f in all_files:
+        basename = os.path.basename(f)
+        group_name = basename[:9] if len(basename) >= 9 else 'Other'
+        groups[group_name].append(f)
+
+    sorted_groups = sorted(groups.items(), 
+                         key=lambda x: max(os.path.getmtime(f) for f in x[1]), 
+                         reverse=True)
+    return sorted_groups
+
 def create_zip_of_files(md_files, mp3_files, wav_files, input_question):
-    """Create zip with intelligent naming based on top 10 common words."""
-    # Exclude 'readme.md'
+    """Create zip with intelligent naming based on high-info terms"""
     md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
     all_files = md_files + mp3_files + wav_files
     if not all_files:
         return None
 
-    # Collect content for high-info term extraction
     all_content = []
     for f in all_files:
         if f.endswith('.md'):
             with open(f, 'r', encoding='utf-8') as file:
                 all_content.append(file.read())
         elif f.endswith('.mp3') or f.endswith('.wav'):
-            # Replace underscores with spaces and extract basename without extension
             basename = os.path.splitext(os.path.basename(f))[0]
             words = basename.replace('_', ' ')
             all_content.append(words)
     
-    # Include the input question
     all_content.append(input_question)
-    
     combined_content = " ".join(all_content)
     info_terms = get_high_info_terms(combined_content, top_n=10)
     
@@ -588,41 +432,12 @@ def create_zip_of_files(md_files, mp3_files, wav_files, input_question):
     name_text = '_'.join(term.replace(' ', '-') for term in info_terms[:10])
     zip_name = f"{timestamp}_{name_text}.zip"
     
-    with zipfile.ZipFile(zip_name,'w') as z:
+    with zipfile.ZipFile(zip_name, 'w') as z:
         for f in all_files:
             z.write(f)
     
     return zip_name
 
-def load_files_for_sidebar():
-    """Load and group files for sidebar display based on first 9 characters of filename"""
-    md_files = glob.glob("*.md")
-    mp3_files = glob.glob("*.mp3")
-    wav_files = glob.glob("*.wav")
-
-    md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
-    all_files = md_files + mp3_files + wav_files
-
-    groups = defaultdict(list)
-    for f in all_files:
-        # Get first 9 characters of filename (timestamp) as group name
-        basename = os.path.basename(f)
-        group_name = basename[:9] if len(basename) >= 9 else 'Other'
-        groups[group_name].append(f)
-
-    # Sort groups based on latest file modification time
-    sorted_groups = sorted(groups.items(), key=lambda x: max(os.path.getmtime(f) for f in x[1]), reverse=True)
-    return sorted_groups
-
-def extract_keywords_from_md(files):
-    """Extract keywords from markdown files"""
-    text = ""
-    for f in files:
-        if f.endswith(".md"):
-            c = open(f,'r',encoding='utf-8').read()
-            text += " " + c
-    return get_high_info_terms(text, top_n=5)
-
 def display_file_manager_sidebar(groups_sorted):
     """Display file manager in sidebar with timestamp-based groups"""
     st.sidebar.title("🎵 Audio & Docs Manager")
@@ -657,16 +472,18 @@ def display_file_manager_sidebar(groups_sorted):
             st.session_state.should_rerun = True
     with top_bar[3]:
         if st.button("⬇️ ZipAll"):
-            zip_name = create_zip_of_files(all_md, all_mp3, all_wav, input_question=st.session_state.get('last_query', ''))
+            zip_name = create_zip_of_files(all_md, all_mp3, all_wav, 
+                                         input_question=st.session_state.get('last_query', ''))
             if zip_name:
-                st.sidebar.markdown(get_download_link(zip_name, file_type="zip"), unsafe_allow_html=True)
+                st.sidebar.markdown(get_download_link(zip_name, file_type="zip"), 
+                                  unsafe_allow_html=True)
 
     for group_name, files in groups_sorted:
         timestamp_dt = datetime.strptime(group_name, "%y%m_%H%M") if len(group_name) == 9 else None
         group_label = timestamp_dt.strftime("%Y-%m-%d %H:%M") if timestamp_dt else group_name
         
         with st.sidebar.expander(f"📁 {group_label} ({len(files)})", expanded=True):
-            c1,c2 = st.columns(2)
+            c1, c2 = st.columns(2)
             with c1:
                 if st.button("👀ViewGrp", key="view_group_"+group_name):
                     st.session_state.viewing_prefix = group_name
@@ -684,57 +501,18 @@ def display_file_manager_sidebar(groups_sorted):
                 ctime = datetime.fromtimestamp(os.path.getmtime(f)).strftime("%H:%M:%S")
                 st.write(f"{emoji} **{fname}** - {ctime}")
 
-# 🎯 11. Main Application
 def main():
+    # Get marquee settings first
+    marquee_settings = get_marquee_settings()
     
-    # Initialize content holder in session state if not present
-    if 'marquee_content' not in st.session_state:
-        st.session_state['marquee_content'] = "🚀 Welcome to TalkingAIResearcher | 🤖 Your Research Assistant"
-    
-    # Load files first
-    groups_sorted = load_files_for_sidebar()
-    
-    # Marquee display with larger text and dynamic content
-    streamlit_marquee(
-        content=st.session_state['marquee_content'],
-        **{
-            **marquee_settings,
-            "font-size": "28px",  
-            "lineHeight": "50px"
-        },
-        key="dynamic_marquee"
-    )
-
-    # Update marquee content when viewing files
-    if st.session_state.viewing_prefix:
-        for group_name, files in groups_sorted:
-            if group_name == st.session_state.viewing_prefix:
-                for f in files:
-                    if f.endswith('.md'):
-                        with open(f, 'r', encoding='utf-8') as file:
-                            st.session_state['marquee_content'] = file.read()[:500]
+    # Initial welcome marquee
+    display_marquee(st.session_state['marquee_content'], 
+                   {**marquee_settings, "font-size": "28px", "lineHeight": "50px"},
+                   key_suffix="welcome")
 
-    # Rest of your main() code...
-    st.sidebar.markdown("### 🚀 TalkingAIResearcher | 🤖 Your Research Assistant")
-    
-    # Add global marquee settings near top of main
-    marquee_settings = display_marquee_controls()
-    
-    # Initialize content holder in session state if not present
-    if 'marquee_content' not in st.session_state:
-        st.session_state['marquee_content'] = "🚀 Welcome to TalkingAIResearcher | 🤖 Your Research Assistant"
+    # Load files for sidebar
+    groups_sorted = load_files_for_sidebar()
     
-    # Marquee display with larger text and dynamic content
-    streamlit_marquee(
-        content=st.session_state['marquee_content'],
-        **{
-            **marquee_settings,
-            "font-size": "28px",  # Larger default text
-            "lineHeight": "50px"  # Increased line height for larger text
-        },
-        key="dynamic_marquee"
-    )
-
     # Update marquee content when viewing files
     if st.session_state.viewing_prefix:
         for group_name, files in groups_sorted:
@@ -742,11 +520,9 @@ def main():
                 for f in files:
                     if f.endswith('.md'):
                         with open(f, 'r', encoding='utf-8') as file:
-                            st.session_state['marquee_content'] = file.read()[:500]  # First 500 chars
-                            
+                            st.session_state['marquee_content'] = file.read()[:280]
 
-    
-    # Add voice selector to sidebar
+    # Voice Settings
     st.sidebar.markdown("### 🎤 Voice Settings")
     selected_voice = st.sidebar.selectbox(
         "Select TTS Voice:",
@@ -754,15 +530,14 @@ def main():
         index=EDGE_TTS_VOICES.index(st.session_state['tts_voice'])
     )
     
-    # Add audio format selector to sidebar
+    # Audio Format Settings
     st.sidebar.markdown("### 🔊 Audio Format")
     selected_format = st.sidebar.radio(
         "Choose Audio Format:",
         options=["MP3", "WAV"],
-        index=0  # Default to MP3
+        index=0
     )
     
-    # Update session state if voice or format changes
     if selected_voice != st.session_state['tts_voice']:
         st.session_state['tts_voice'] = selected_voice
         st.rerun()
@@ -770,33 +545,33 @@ def main():
         st.session_state['audio_format'] = selected_format.lower()
         st.rerun()
 
-    tab_main = st.radio("Action:",["🎤 Voice","📸 Media","🔍 ArXiv","📝 Editor"],horizontal=True)
+    # Main Interface
+    tab_main = st.radio("Action:", ["🎤 Voice", "📸 Media", "🔍 ArXiv", "📝 Editor"], 
+                       horizontal=True)
 
     mycomponent = components.declare_component("mycomponent", path="mycomponent")
     val = mycomponent(my_input_value="Hello")
 
-    # Show input in a text box for editing if detected
     if val:
         val_stripped = val.replace('\\n', ' ')
         edited_input = st.text_area("✏️ Edit Input:", value=val_stripped, height=100)
-        #edited_input = edited_input.replace('\n', ' ')
         
         run_option = st.selectbox("Model:", ["Arxiv", "GPT-4o", "Claude-3.5"])
         col1, col2 = st.columns(2)
         with col1:
             autorun = st.checkbox("⚙ AutoRun", value=True)
         with col2:
-            full_audio = st.checkbox("📚FullAudio", value=False, 
-                                     help="Generate full audio response")
+            full_audio = st.checkbox("📚FullAudio", value=False)
 
         input_changed = (val != st.session_state.old_val)
 
         if autorun and input_changed:
             st.session_state.old_val = val
-            st.session_state.last_query = edited_input  # Store the last query for zip naming
+            st.session_state.last_query = edited_input
             if run_option == "Arxiv":
                 perform_ai_lookup(edited_input, vocal_summary=True, extended_refs=False, 
-                                  titles_summary=True, full_audio=full_audio)
+                                titles_summary=True, full_audio=full_audio,
+                                marquee_settings=marquee_settings)
             else:
                 if run_option == "GPT-4o":
                     process_with_gpt(edited_input)
@@ -805,23 +580,19 @@ def main():
         else:
             if st.button("▶ Run"):
                 st.session_state.old_val = val
-                st.session_state.last_query = edited_input  # Store the last query for zip naming
+                st.session_state.last_query = edited_input
                 if run_option == "Arxiv":
                     perform_ai_lookup(edited_input, vocal_summary=True, extended_refs=False, 
-                                      titles_summary=True, full_audio=full_audio)
+                                    titles_summary=True, full_audio=full_audio,
+                                    marquee_settings=marquee_settings)
                 else:
                     if run_option == "GPT-4o":
                         process_with_gpt(edited_input)
                     elif run_option == "Claude-3.5":
                         process_with_claude(edited_input)
     
-        
+    # ArXiv Tab
     if tab_main == "🔍 ArXiv":
-        papers = parse_arxiv_refs(refs)
-        if papers:
-            paper_texts = [f"📄 {p['title']} | {p['authors']}" for p in papers]
-            st.session_state['marquee_content'] = " ⭐ ".join(paper_texts)
-
         st.subheader("🔍 Query ArXiv")
         q = st.text_input("🔍 Query:")
 
@@ -829,35 +600,28 @@ def main():
         vocal_summary = st.checkbox("🎙ShortAudio", value=True)
         extended_refs = st.checkbox("📜LongRefs", value=False)
         titles_summary = st.checkbox("🔖TitlesOnly", value=True)
-        full_audio = st.checkbox("📚FullAudio", value=False,
-                                 help="Full audio of results")
-        full_transcript = st.checkbox("🧾FullTranscript", value=False,
-                                      help="Generate a full transcript file")
+        full_audio = st.checkbox("📚FullAudio", value=False)
+        full_transcript = st.checkbox("🧾FullTranscript", value=False)
 
         if q and st.button("🔍Run"):
-            st.session_state.last_query = q  # Store the last query for zip naming
+            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)
+                                     titles_summary=titles_summary, full_audio=full_audio,
+                                     marquee_settings=marquee_settings)
             if full_transcript:
-                save_full_transcript(q, result)
-
-        st.markdown("### Change Prompt & Re-Run")
-        q_new = st.text_input("🔄 Modify Query:")
-        if q_new and st.button("🔄 Re-Run with Modified Query"):
-            st.session_state.last_query = q_new  # Update last query
-            result = perform_ai_lookup(q_new, vocal_summary=vocal_summary, extended_refs=extended_refs, 
-                                       titles_summary=titles_summary, full_audio=full_audio)
-            if full_transcript:
-                save_full_transcript(q_new, result)
+                create_file(q, result, "md")
 
+    # Voice Tab
     elif tab_main == "🎤 Voice":
         st.subheader("🎤 Voice Input")
         user_text = st.text_area("💬 Message:", height=100)
         user_text = user_text.strip().replace('\n', ' ')
+
         if st.button("📨 Send"):
             process_with_gpt(user_text)
+            
         st.subheader("📜 Chat History")
-        t1,t2=st.tabs(["Claude History","GPT-4o History"])
+        t1, t2 = st.tabs(["Claude History", "GPT-4o History"])
         with t1:
             for c in st.session_state.chat_history:
                 st.write("**You:**", c["user"])
@@ -867,22 +631,33 @@ def main():
                 with st.chat_message(m["role"]):
                     st.markdown(m["content"])
 
+    # Media Tab
     elif tab_main == "📸 Media":
         st.header("📸 Images & 🎥 Videos")
         tabs = st.tabs(["🖼 Images", "🎥 Video"])
         with tabs[0]:
-            imgs = glob.glob("*.png")+glob.glob("*.jpg")
+            imgs = glob.glob("*.png") + glob.glob("*.jpg")
             if imgs:
-                c = st.slider("Cols",1,5,3)
+                c = st.slider("Cols", 1, 5, 3)
                 cols = st.columns(c)
-                for i,f in enumerate(imgs):
-                    with cols[i%c]:
-                        st.image(Image.open(f),use_container_width=True)
+                for i, f in enumerate(imgs):
+                    with cols[i % c]:
+                        st.image(Image.open(f), use_container_width=True)
                         if st.button(f"👀 Analyze {os.path.basename(f)}", key=f"analyze_{f}"):
-                            a = process_image(f,"Describe this image.")
-                            st.markdown(a)
+                            response = openai_client.chat.completions.create(
+                                model=st.session_state["openai_model"],
+                                messages=[
+                                    {"role": "system", "content": "Analyze the image content."},
+                                    {"role": "user", "content": [
+                                        {"type": "image_url", 
+                                         "image_url": {"url": f"data:image/jpeg;base64,{base64.b64encode(open(f, 'rb').read()).decode()}"}}
+                                    ]}
+                                ]
+                            )
+                            st.markdown(response.choices[0].message.content)
             else:
                 st.write("No images found.")
+        
         with tabs[1]:
             vids = glob.glob("*.mp4")
             if vids:
@@ -890,27 +665,40 @@ def main():
                     with st.expander(f"🎥 {os.path.basename(v)}"):
                         st.video(v)
                         if st.button(f"Analyze {os.path.basename(v)}", key=f"analyze_{v}"):
-                            a = process_video_with_gpt(v,"Describe video.")
-                            st.markdown(a)
+                            frames = process_video(v)
+                            response = openai_client.chat.completions.create(
+                                model=st.session_state["openai_model"],
+                                messages=[
+                                    {"role": "system", "content": "Analyze video frames."},
+                                    {"role": "user", "content": [
+                                        {"type": "image_url", 
+                                         "image_url": {"url": f"data:image/jpeg;base64,{frame}"}}
+                                        for frame in frames
+                                    ]}
+                                ]
+                            )
+                            st.markdown(response.choices[0].message.content)
             else:
                 st.write("No videos found.")
 
+    # Editor Tab
     elif tab_main == "📝 Editor":
-        if getattr(st.session_state,'current_file',None):
-            st.subheader(f"Editing: {st.session_state.current_file}")
-            new_text = st.text_area("✏️ Content:", st.session_state.file_content, height=300)
+        if st.session_state.editing_file:
+            st.subheader(f"Editing: {st.session_state.editing_file}")
+            new_text = st.text_area("✏️ Content:", st.session_state.edit_new_content, height=300)
             if st.button("💾 Save"):
-                with open(st.session_state.current_file,'w',encoding='utf-8') as f:
+                with open(st.session_state.editing_file, 'w', encoding='utf-8') as f:
                     f.write(new_text)
-                st.success("Updated!")
+                st.success("File updated successfully!")
                 st.session_state.should_rerun = True
+                st.session_state.editing_file = None
         else:
             st.write("Select a file from the sidebar to edit.")
 
-    # Load and display files in the sidebar
-    groups_sorted = load_files_for_sidebar()
+    # Display file manager in sidebar
     display_file_manager_sidebar(groups_sorted)
 
+    # Display viewed group content
     if st.session_state.viewing_prefix and any(st.session_state.viewing_prefix == group for group, _ in groups_sorted):
         st.write("---")
         st.write(f"**Viewing Group:** {st.session_state.viewing_prefix}")
@@ -921,146 +709,30 @@ def main():
                     ext = os.path.splitext(fname)[1].lower().strip('.')
                     st.write(f"### {fname}")
                     if ext == "md":
-                        content = open(f,'r',encoding='utf-8').read()
+                        content = open(f, 'r', encoding='utf-8').read()
                         st.markdown(content)
-                    elif ext == "mp3":
+                    elif ext in ["mp3", "wav"]:
                         st.audio(f)
-                    elif ext == "wav":
-                        st.audio(f)  # 🆕 Handle WAV files
                     else:
                         st.markdown(get_download_link(f), unsafe_allow_html=True)
                 break
         if st.button("❌ Close"):
             st.session_state.viewing_prefix = None
-
-    markdownPapers = """
-    
-    # Levels of AGI
-
-## 1. Performance (rows) x Generality (columns)
-- **Narrow**  
-  - *clearly scoped or set of tasks*  
-- **General**  
-  - *wide range of non-physical tasks, including metacognitive abilities like learning new skills*  
-
-## 2. Levels of AGI
-
-### 2.1 Level 0: No AI
-- **Narrow Non-AI**  
-  - Calculator software; compiler  
-- **General Non-AI**  
-  - Human-in-the-loop computing, e.g., Amazon Mechanical Turk  
-
-### 2.2 Level 1: Emerging  
-*equal to or somewhat better than an unskilled human*  
-- **Emerging Narrow AI**  
-  - GOFAI; simple rule-based systems  
-  - Example: SHRDLU  
-    - *Reference:* Winograd, T. (1971). **Procedures as a Representation for Data in a Computer Program for Understanding Natural Language**. MIT AI Technical Report. [Link](https://dspace.mit.edu/handle/1721.1/7095)  
-- **Emerging AGI**  
-  - ChatGPT (OpenAI, 2023)  
-  - Bard (Anil et al., 2023)  
-    - *Reference:* Anil, R., et al. (2023). **Bard: Google’s AI Chatbot**. [arXiv](https://arxiv.org/abs/2303.12712)  
-  - LLaMA 2 (Touvron et al., 2023)  
-    - *Reference:* Touvron, H., et al. (2023). **LLaMA 2: Open and Efficient Foundation Language Models**. [arXiv](https://arxiv.org/abs/2307.09288)  
-
-### 2.3 Level 2: Competent  
-*at least 50th percentile of skilled adults*  
-- **Competent Narrow AI**  
-  - Toxicity detectors such as Jigsaw  
-    - *Reference:* Das, S., et al. (2022). **Toxicity Detection at Scale with Jigsaw**. [arXiv](https://arxiv.org/abs/2204.06905)  
-  - Smart Speakers (Apple, Amazon, Google)  
-  - VQA systems (PaLI)  
-    - *Reference:* Chen, T., et al. (2023). **PaLI: Pathways Language and Image model**. [arXiv](https://arxiv.org/abs/2301.01298)  
-  - Watson (IBM)  
-  - SOTA LLMs for subsets of tasks  
-- **Competent AGI**  
-  - Not yet achieved  
-
-### 2.4 Level 3: Expert  
-*at least 90th percentile of skilled adults*  
-- **Expert Narrow AI**  
-  - Spelling & grammar checkers (Grammarly, 2023)  
-  - Generative image models  
-    - Example: Imagen  
-      - *Reference:* Saharia, C., et al. (2022). **Imagen: Photorealistic Text-to-Image Diffusion Models**. [arXiv](https://arxiv.org/abs/2205.11487)  
-    - Example: DALL·E 2  
-      - *Reference:* Ramesh, A., et al. (2022). **Hierarchical Text-Conditional Image Generation with CLIP Latents**. [arXiv](https://arxiv.org/abs/2204.06125)  
-- **Expert AGI**  
-  - Not yet achieved  
-
-### 2.5 Level 4: Virtuoso  
-*at least 99th percentile of skilled adults*  
-- **Virtuoso Narrow AI**  
-  - Deep Blue  
-    - *Reference:* Campbell, M., et al. (2002). **Deep Blue**. IBM Journal of Research and Development. [Link](https://research.ibm.com/publications/deep-blue)  
-  - AlphaGo  
-    - *Reference:* Silver, D., et al. (2016, 2017). **Mastering the Game of Go with Deep Neural Networks and Tree Search**. [Nature](https://www.nature.com/articles/nature16961)  
-- **Virtuoso AGI**  
-  - Not yet achieved  
-
-### 2.6 Level 5: Superhuman  
-*outperforms 100% of humans*  
-- **Superhuman Narrow AI**  
-  - AlphaFold  
-    - *Reference:* Jumper, J., et al. (2021). **Highly Accurate Protein Structure Prediction with AlphaFold**. [Nature](https://www.nature.com/articles/s41586-021-03819-2)  
-  - AlphaZero  
-    - *Reference:* Silver, D., et al. (2018). **A General Reinforcement Learning Algorithm that Masters Chess, Shogi, and Go through Self-Play**. [Science](https://www.science.org/doi/10.1126/science.aar6404)  
-  - StockFish  
-    - *Reference:* Stockfish (2023). **Stockfish Chess Engine**. [Website](https://stockfishchess.org)  
-- **Artificial Superintelligence (ASI)**  
-  - Not yet achieved  
-
-
-# 🧬 Innovative Architecture of AlphaFold2: A Hybrid System
-
-## 1. 🔢 Input Sequence  
-- The process starts with an **input sequence** (protein sequence).  
-
-## 2. 🗄️ Database Searches  
-- **Genetic database search** 🔍  
-  - Searches genetic databases to retrieve related sequences.  
-- **Structure database search** 🔍  
-  - Searches structural databases for template structures.  
-- **Pairing** 🤝  
-  - Aligns sequences and structures for further analysis.  
-
-## 3. 🧩 MSA (Multiple Sequence Alignment)  
-- **MSA representation** 📊 (r,c)  
-  - Representation of multiple aligned sequences used as input.  
-
-## 4. 📑 Templates  
-- Template structures are paired to assist the model.  
-
-## 5. 🔄 Evoformer (48 blocks)  
-- A **deep learning module** that refines representations:  
-  - **MSA representation** 🧱  
-  - **Pair representation** 🧱 (r,c)  
-
-## 6. 🧱 Structure Module (8 blocks)  
-- Converts the representations into:  
-  - **Single representation** (r,c)  
-  - **Pair representation** (r,c)  
-
-## 7. 🧬 3D Structure Prediction  
-- The structure module predicts the **3D protein structure**.  
-- **Confidence levels**:  
-  - 🔵 *High confidence*  
-  - 🟠 *Low confidence*  
-
-## 8. ♻️ Recycling (Three Times)  
-- The model **recycles** its output up to three times to refine the prediction.  
-
-## 9. 📚 Reference  
-**Jumper, J., et al. (2021).** Highly Accurate Protein Structure Prediction with AlphaFold. *Nature.*  
-🔗 [Nature Publication Link](https://www.nature.com/articles/s41586-021-03819-2)  
-
-    """
-    st.sidebar.markdown(markdownPapers)
-    
+            st.session_state['marquee_content'] = "🚀 Welcome to TalkingAIResearcher | 🤖 Your Research Assistant"
+
+    # Add custom CSS
+    st.markdown("""
+    <style>
+        .main { background: linear-gradient(to right, #1a1a1a, #2d2d2d); color: #fff; }
+        .stMarkdown { font-family: 'Helvetica Neue', sans-serif; }
+        .stButton>button { margin-right: 0.5rem; }
+    </style>
+    """, unsafe_allow_html=True)
+
+    # Handle rerun if needed
     if st.session_state.should_rerun:
         st.session_state.should_rerun = False
         st.rerun()
 
-if __name__=="__main__":
+if __name__ == "__main__":
     main()