Update app.py

app.py

@@ -5,7 +5,7 @@ import streamlit.components.v1 as components
 from datetime import datetime
 from audio_recorder_streamlit import audio_recorder
 from bs4 import BeautifulSoup
-from collections import defaultdict, deque
+from collections import defaultdict, deque, Counter
 from dotenv import load_dotenv
 from gradio_client import Client
 from huggingface_hub import InferenceClient
@@ -19,6 +19,7 @@ import extra_streamlit_components as stx
 from streamlit.runtime.scriptrunner import get_script_run_ctx
 import asyncio
 import edge_tts
+import moviepy.editor as mp  # 🆕 Import moviepy for MP4 generation
 
 # 🎯 1. Core Configuration & Setup
 st.set_page_config(
@@ -50,7 +51,8 @@ EDGE_TTS_VOICES = [
 # Add this to your session state initialization section:
 if 'tts_voice' not in st.session_state:
     st.session_state['tts_voice'] = EDGE_TTS_VOICES[0]  # Default voice
-    
+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', "")
@@ -90,6 +92,8 @@ 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'] = ""  # 🆕 Store the last query for zip naming
 
 # 🎨 4. Custom CSS
 st.markdown("""
@@ -105,10 +109,11 @@ st.markdown("""
 FILE_EMOJIS = {
     "md": "📝",
     "mp3": "🎵",
+    "mp4": "🎬"  # 🆕 Add emoji for MP4
 }
 
 # 🧠 5. High-Information Content Extraction
-def get_high_info_terms(text: str) -> list:
+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',
@@ -130,35 +135,23 @@ def get_high_info_terms(text: str) -> list:
         'research paper', 'scientific study', 'empirical analysis'
     ]
 
-    # Identify key phrases
-    #preserved_phrases = []
-    #lower_text = text.lower()
-    #for phrase in key_phrases:
-    #    if phrase in lower_text:
-    #        preserved_phrases.append(phrase)
-    #        text = text.replace(phrase, '')
-
-    # Extract individual words
-    words = re.findall(r'\b\w+(?:-\w+)*\b', text)
-    high_info_words = [
-        word.lower() for word in words 
-        if len(word) > 3
-        and word.lower() not in stop_words
-        and not word.isdigit()
-        and any(c.isalpha() for c in word)
+    # Extract bi-grams and uni-grams
+    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)
     ]
 
-    #all_terms = preserved_phrases + high_info_words
-    all_terms = high_info_words
-    seen = set()
-    unique_terms = []
-    for term in all_terms:
-        if term not in seen:
-            seen.add(term)
-            unique_terms.append(term)
-
-    max_terms = 5
-    return unique_terms[:max_terms]
+    # Count frequencies
+    counter = Counter(filtered)
+    most_common = [term for term, freq in counter.most_common(top_n)]
+    return most_common
 
 def clean_text_for_filename(text: str) -> str:
     """Remove punctuation and short filler words, return a compact string."""
@@ -177,7 +170,7 @@ def generate_filename(prompt, response, file_type="md"):
     """
     prefix = datetime.now().strftime("%y%m_%H%M") + "_"
     combined = (prompt + " " + response).strip()
-    info_terms = get_high_info_terms(combined)
+    info_terms = get_high_info_terms(combined, top_n=10)
     
     # Include a short snippet from prompt and response
     snippet = (prompt[:100] + " " + response[:100]).strip()
@@ -201,11 +194,20 @@ def create_file(prompt, response, file_type="md"):
         f.write(prompt + "\n\n" + response)
     return filename
 
-def get_download_link(file):
+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()
-    return f'<a href="data:file/zip;base64,{b64}" download="{os.path.basename(file)}">📂 Download {os.path.basename(file)}</a>'
+    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 == "mp4":
+        return f'<a href="data:video/mp4;base64,{b64}" download="{os.path.basename(file)}">🎬 Download {os.path.basename(file)}</a>'  # 🆕 MP4 download link
+    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:
@@ -230,7 +232,7 @@ def speech_synthesis_html(result):
     """
     components.html(html_code, height=0)
 
-async def edge_tts_generate_audio(text, voice="en-US-AriaNeural", rate=0, pitch=0):
+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():
@@ -238,19 +240,44 @@ async def edge_tts_generate_audio(text, voice="en-US-AriaNeural", rate=0, pitch=
     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, "mp3")
-    await communicate.save(out_fn)
-    return out_fn
+    if file_format == "mp3":
+        out_fn = generate_filename(text, text, "mp3")
+        await communicate.save(out_fn)
+        return out_fn
+    elif file_format == "mp4":
+        # Generate MP3 first
+        mp3_filename = generate_filename(text, text, "mp3")
+        await communicate.save(mp3_filename)
+        
+        # Create MP4 by combining MP3 with a placeholder image
+        placeholder_image = "placeholder.jpg"  # 🆕 Ensure this image exists in your directory
+        if not os.path.exists(placeholder_image):
+            st.error(f"Placeholder image '{placeholder_image}' not found. Please add it to the directory.")
+            return mp3_filename  # Return MP3 if image not found
+        
+        video_filename = os.path.splitext(mp3_filename)[0] + ".mp4"
+        try:
+            audio_clip = mp.AudioFileClip(mp3_filename)
+            image_clip = mp.ImageClip(placeholder_image).set_duration(audio_clip.duration)
+            video_clip = image_clip.set_audio(audio_clip)
+            video_clip.write_videofile(video_filename, codec="libx264", audio_codec="aac", verbose=False, logger=None)
+            return video_filename
+        except Exception as e:
+            st.warning(f"Error generating MP4 for {mp3_filename}: {str(e)}")
+            return mp3_filename  # Return MP3 if MP4 generation fails
 
-def speak_with_edge_tts(text, voice="en-US-AriaNeural", rate=0, pitch=0):
+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))
+    return asyncio.run(edge_tts_generate_audio(text, voice, rate, pitch, file_format))
 
-def play_and_download_audio(file_path):
-    """Play and provide download link for audio"""
+def play_and_download_audio(file_path, file_type="mp3"):
+    """Play and provide download link for audio/video"""
     if file_path and os.path.exists(file_path):
-        st.audio(file_path)
-        dl_link = f'<a href="data:audio/mpeg;base64,{base64.b64encode(open(file_path,"rb").read()).decode()}" download="{os.path.basename(file_path)}">Download {os.path.basename(file_path)}</a>'
+        if file_type in ["mp3", "wav"]:
+            st.audio(file_path)
+        elif file_type == "mp4":
+            st.video(file_path)  # 🆕 Use st.video for MP4 files
+        dl_link = get_download_link(file_path, file_type=file_type)
         st.markdown(dl_link, unsafe_allow_html=True)
 
 # 🎬 8. Media Processing
@@ -317,8 +344,6 @@ def save_full_transcript(query, text):
     """Save full transcript of Arxiv results as a file."""
     create_file(query, text, "md")
 
-
-
 def parse_arxiv_refs(ref_text: str):
     """
     Parse papers by finding lines with two pipe characters as title lines.
@@ -379,29 +404,46 @@ def parse_arxiv_refs(ref_text: str):
     
     return results[:20]  # Ensure we return maximum 20 papers
 
-
-
-def create_paper_audio_files(papers):
+def create_paper_audio_files(papers, input_question):
     """
     Create audio files for each paper's content and add file paths to paper dict.
-    Only generates full audio file since it includes the title.
+    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)
-            full_file = speak_with_edge_tts(full_text, voice=st.session_state['tts_voice'])
+            # Determine file format based on user selection
+            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/video 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)
+            
+            combined_titles.append(paper['title'])
+        
         except Exception as e:
             st.warning(f"Error generating audio for paper {paper['title']}: {str(e)}")
             paper['full_audio'] = None
 
-            
+    # After all individual audios, create a combined summary audio/video
+    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 {'Video' if file_format=='mp4' else '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 using URLs as unique keys.
+    Display papers with their audio/video controls using URLs as unique keys.
     """
     st.write("## Research Papers")
     
@@ -411,15 +453,18 @@ def display_papers(papers):
             st.markdown(f"*{paper['authors']}*")
             st.markdown(paper['summary'])
             
-            # Single audio control for full content
+            # Single audio/video control for full content
             if paper.get('full_audio'):
-                st.write("📚 Paper Audio")
-                st.audio(paper['full_audio'])
-
+                st.write("📚 Paper Audio/Video")
+                file_ext = os.path.splitext(paper['full_audio'])[1].lower()
+                if file_ext == ".mp3":
+                    st.audio(paper['full_audio'])
+                elif file_ext == ".mp4":
+                    st.video(paper['full_audio'])
 
 def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, 
                      titles_summary=True, full_audio=False):
-    """Perform Arxiv search with audio generation per paper."""
+    """Perform Arxiv search with audio/video generation per paper."""
     start = time.time()
 
     # Query the HF RAG pipeline
@@ -437,7 +482,7 @@ def perform_ai_lookup(q, vocal_summary=True, extended_refs=False,
     # Parse and process papers
     papers = parse_arxiv_refs(refs)
     if papers:
-        create_paper_audio_files(papers)
+        create_paper_audio_files(papers, input_question=q)
         display_papers(papers)
     else:
         st.warning("No papers found in the response.")
@@ -449,9 +494,6 @@ def perform_ai_lookup(q, vocal_summary=True, extended_refs=False,
     create_file(q, result, "md")
     return result
 
-
-    
-
 def process_with_gpt(text):
     """Process text with GPT-4"""
     if not text: 
@@ -490,10 +532,11 @@ def process_with_claude(text):
     return ans
 
 # 📂 10. File Management
-def create_zip_of_files(md_files, mp3_files):
-    """Create zip with intelligent naming"""
+def create_zip_of_files(md_files, mp3_files, mp4_files, input_question):
+    """Create zip with intelligent naming based on top 10 common words."""
+    # Exclude 'readme.md'
     md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
-    all_files = md_files + mp3_files
+    all_files = md_files + mp3_files + mp4_files
     if not all_files:
         return None
 
@@ -504,13 +547,24 @@ def create_zip_of_files(md_files, mp3_files):
             with open(f, 'r', encoding='utf-8') as file:
                 all_content.append(file.read())
         elif f.endswith('.mp3'):
-            all_content.append(os.path.basename(f))
+            # 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)
+        elif f.endswith('.mp4'):
+            # 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)
+    info_terms = get_high_info_terms(combined_content, top_n=10)
     
     timestamp = datetime.now().strftime("%y%m_%H%M")
-    name_text = '_'.join(term.replace(' ', '-') for term in info_terms[:3])
+    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:
@@ -523,23 +577,23 @@ def load_files_for_sidebar():
     """Load and group files for sidebar display"""
     md_files = glob.glob("*.md")
     mp3_files = glob.glob("*.mp3")
+    mp4_files = glob.glob("*.mp4")  # 🆕 Load MP4 files
 
     md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
-    all_files = md_files + mp3_files
+    all_files = md_files + mp3_files + mp4_files
 
     groups = defaultdict(list)
     for f in all_files:
-        fname = os.path.basename(f)
-        prefix = fname[:10]
-        groups[prefix].append(f)
+        # Treat underscores as spaces and split into words
+        words = os.path.basename(f).replace('_', ' ').split()
+        # Extract keywords from filename
+        keywords = get_high_info_terms(' '.join(words), top_n=5)
+        group_name = '_'.join(keywords) if keywords else 'Miscellaneous'
+        groups[group_name].append(f)
 
-    for prefix in groups:
-        groups[prefix].sort(key=lambda x: os.path.getmtime(x), reverse=True)
-
-    sorted_prefixes = sorted(groups.keys(), 
-                           key=lambda pre: max(os.path.getmtime(x) for x in groups[pre]), 
-                           reverse=True)
-    return groups, sorted_prefixes
+    # 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"""
@@ -548,22 +602,25 @@ def extract_keywords_from_md(files):
         if f.endswith(".md"):
             c = open(f,'r',encoding='utf-8').read()
             text += " " + c
-    return get_high_info_terms(text)
+    return get_high_info_terms(text, top_n=5)
 
-def display_file_manager_sidebar(groups, sorted_prefixes):
+def display_file_manager_sidebar(groups_sorted):
     """Display file manager in sidebar"""
     st.sidebar.title("🎵 Audio & Docs Manager")
 
     all_md = []
     all_mp3 = []
-    for prefix in groups:
-        for f in groups[prefix]:
+    all_mp4 = []  # 🆕 List to hold MP4 files
+    for group_name, files in groups_sorted:
+        for f in files:
             if f.endswith(".md"):
                 all_md.append(f)
             elif f.endswith(".mp3"):
                 all_mp3.append(f)
+            elif f.endswith(".mp4"):
+                all_mp4.append(f)  # 🆕 Append MP4 files
 
-    top_bar = st.sidebar.columns(3)
+    top_bar = st.sidebar.columns(4)  # 🆕 Adjusted columns to accommodate MP4
     with top_bar[0]:
         if st.button("🗑 DelAllMD"):
             for f in all_md:
@@ -575,25 +632,28 @@ def display_file_manager_sidebar(groups, sorted_prefixes):
                 os.remove(f)
             st.session_state.should_rerun = True
     with top_bar[2]:
+        if st.button("🗑 DelAllMP4"):
+            for f in all_mp4:
+                os.remove(f)
+            st.session_state.should_rerun = True
+    with top_bar[3]:
         if st.button("⬇️ ZipAll"):
-            z = create_zip_of_files(all_md, all_mp3)
-            if z:
-                st.sidebar.markdown(get_download_link(z),unsafe_allow_html=True)
-
-    for prefix in sorted_prefixes:
-        files = groups[prefix]
-        kw = extract_keywords_from_md(files)
-        keywords_str = " ".join(kw) if kw else "No Keywords"
-        with st.sidebar.expander(f"{prefix} Files ({len(files)}) - KW: {keywords_str}", expanded=True):
+            zip_name = create_zip_of_files(all_md, all_mp3, all_mp4, 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)
+
+    for group_name, files in groups_sorted:
+        keywords_str = group_name.replace('_', ' ') if group_name else "No Keywords"
+        with st.sidebar.expander(f"{FILE_EMOJIS.get('md', '')} {group_name} Files ({len(files)}) - KW: {keywords_str}", expanded=True):
             c1,c2 = st.columns(2)
             with c1:
-                if st.button("👀ViewGrp", key="view_group_"+prefix):
-                    st.session_state.viewing_prefix = prefix
+                if st.button("👀ViewGrp", key="view_group_"+group_name):
+                    st.session_state.viewing_prefix = group_name
             with c2:
-                if st.button("🗑DelGrp", key="del_group_"+prefix):
+                if st.button("🗑DelGrp", key="del_group_"+group_name):
                     for f in files:
                         os.remove(f)
-                    st.success(f"Deleted group {prefix}!")
+                    st.success(f"Deleted group {group_name}!")
                     st.session_state.should_rerun = True
 
             for f in files:
@@ -613,11 +673,21 @@ def main():
         index=EDGE_TTS_VOICES.index(st.session_state['tts_voice'])
     )
     
-    # Update session state if voice changes
+    # Add audio format selector to sidebar
+    st.sidebar.markdown("### 🔊 Audio Format")
+    selected_format = st.sidebar.radio(
+        "Choose Audio Format:",
+        options=["MP3", "MP4"],
+        index=0  # Default to MP3
+    )
+    
+    # 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()
-
+    if selected_format.lower() != st.session_state['audio_format']:
+        st.session_state['audio_format'] = selected_format.lower()
+        st.rerun()
 
     tab_main = st.radio("Action:",["🎤 Voice","📸 Media","🔍 ArXiv","📝 Editor"],horizontal=True)
 
@@ -642,6 +712,7 @@ def main():
 
         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
             if run_option == "Arxiv":
                 perform_ai_lookup(edited_input, vocal_summary=True, extended_refs=False, 
                                   titles_summary=True, full_audio=full_audio)
@@ -653,6 +724,7 @@ 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
                 if run_option == "Arxiv":
                     perform_ai_lookup(edited_input, vocal_summary=True, extended_refs=False, 
                                       titles_summary=True, full_audio=full_audio)
@@ -676,6 +748,7 @@ def main():
                                       help="Generate a full transcript file")
 
         if q and st.button("🔍Run"):
+            st.session_state.last_query = q  # Store the last query for zip naming
             result = perform_ai_lookup(q, vocal_summary=vocal_summary, extended_refs=extended_refs, 
                                        titles_summary=titles_summary, full_audio=full_audio)
             if full_transcript:
@@ -684,6 +757,7 @@ def main():
         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:
@@ -746,23 +820,29 @@ def main():
         else:
             st.write("Select a file from the sidebar to edit.")
 
-    groups, sorted_prefixes = load_files_for_sidebar()
-    display_file_manager_sidebar(groups, sorted_prefixes)
+    # Load and display files in the sidebar
+    groups_sorted = load_files_for_sidebar()
+    display_file_manager_sidebar(groups_sorted)
 
-    if st.session_state.viewing_prefix and st.session_state.viewing_prefix in groups:
+    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}")
-        for f in groups[st.session_state.viewing_prefix]:
-            fname = os.path.basename(f)
-            ext = os.path.splitext(fname)[1].lower().strip('.')
-            st.write(f"### {fname}")
-            if ext == "md":
-                content = open(f,'r',encoding='utf-8').read()
-                st.markdown(content)
-            elif ext == "mp3":
-                st.audio(f)
-            else:
-                st.markdown(get_download_link(f), unsafe_allow_html=True)
+        for group_name, files in groups_sorted:
+            if group_name == st.session_state.viewing_prefix:
+                for f in files:
+                    fname = os.path.basename(f)
+                    ext = os.path.splitext(fname)[1].lower().strip('.')
+                    st.write(f"### {fname}")
+                    if ext == "md":
+                        content = open(f,'r',encoding='utf-8').read()
+                        st.markdown(content)
+                    elif ext == "mp3":
+                        st.audio(f)
+                    elif ext == "mp4":
+                        st.video(f)  # 🆕 Handle MP4 files
+                    else:
+                        st.markdown(get_download_link(f), unsafe_allow_html=True)
+                break
         if st.button("❌ Close"):
             st.session_state.viewing_prefix = None