Update app.py

app.py

@@ -1,193 +1,120 @@
+```python
 import os
 import base64
-import re
-import requests
-import pytz
-import json
-from io import BytesIO
-from datetime import datetime
 import gradio as gr
 import openai
-import fitz  # pymupdf
-from bs4 import BeautifulSoup
+import fitz  # PyMuPDF
+from io import BytesIO
 from moviepy.video.io.VideoFileClip import VideoFileClip
+from gtts import gTTS
+from gradio_client import Client
 
 # 🔐 CONFIG
 KEY_FILE = "openai_api_key.txt"
 MODEL = "gpt-4o-2024-05-13"
 
-# 🍿 Default key load
+# Load stored API key
+DEFAULT_KEY = ""
 if os.path.exists(KEY_FILE):
     with open(KEY_FILE, 'r') as f:
         DEFAULT_KEY = f.read().strip()
-else:
-    DEFAULT_KEY = ''
 
-# 🔧 HELPERS
-def save_api_key(api_key):
+# 🔧 Helpers
+def save_api_key(key):
     with open(KEY_FILE, 'w') as f:
-        f.write(api_key.strip())
+        f.write(key.strip())
     return "🔑 Key saved!"
 
-# 🗒️ Chat
+def get_api_key(input_key):
+    # Priority: user input > stored > ENV
+    if input_key and input_key.strip():
+        save_api_key(input_key)
+        return input_key.strip()
+    if DEFAULT_KEY:
+        return DEFAULT_KEY
+    env = os.getenv('OPENAI_KEY', '')
+    if env:
+        save_api_key(env)
+        return env
+    raise gr.Error("❗ OpenAI API key required.")
+
+# 📋 Gallery Processing
+def apply_filters(files, filters):
+    selected = []
+    for f in files:
+        lower = f.lower()
+        if any(lower.endswith(ext) for ext in ['.png', '.jpg', '.jpeg']) and '🖼️ Images' in filters:
+            selected.append((f, 'image'))
+        if any(lower.endswith(ext) for ext in ['.wav', '.mp3']) and '🎤 Audio' in filters:
+            selected.append((f, 'audio'))
+        if any(lower.endswith(ext) for ext in ['.mp4', '.webm']) and '🎥 Video' in filters:
+            selected.append((f, 'video'))
+        if lower.endswith('.pdf') and '📄 PDF' in filters:
+            selected.append((f, 'pdf'))
+    return selected
+
+def generate_table(selected, api_key):
+    key = get_api_key(api_key)
+    openai.api_key = key
+    # Build markdown table
+    md = "| ✅ | Type | Filename |\n|---|------|----------|\n"
+    for path, typ in selected:
+        emoji = '🖼️' if typ=='image' else '🎤' if typ=='audio' else '🎥' if typ=='video' else '📄'
+        name = os.path.basename(path)
+        md += f"| ✅ | {emoji} {typ.capitalize()} | {name} |\n"
+    return md
 
-def chat_with_openai(api_key, user_message, history):
-    openai.api_key = api_key.strip()
+# 🗨️ Chat Handler
+def chat_handler(api_key, message, history):
+    key = get_api_key(api_key)
+    openai.api_key = key
     messages = []
     for u, a in history:
-        messages.append({"role": "user", "content": u})
-        messages.append({"role": "assistant", "content": a})
-    messages.append({"role": "user", "content": user_message})
+        messages.append({"role": "user",    "content": u})
+        messages.append({"role": "assistant","content": a})
+    messages.append({"role": "user", "content": message})
     resp = openai.ChatCompletion.create(model=MODEL, messages=messages)
     answer = resp.choices[0].message.content
-    history.append((user_message, answer))
+    history.append((message, answer))
     return history
 
-# 🖼️ Image analysis
-def image_to_base64(file):
-    return base64.b64encode(file.read()).decode()
-
-def analyze_image(api_key, file, prompt):
-    data_uri = f"data:image/png;base64,{image_to_base64(file)}"
-    openai.api_key = api_key.strip()
-    resp = openai.ChatCompletion.create(
-        model=MODEL,
-        messages=[
-            {"role": "system", "content": "You are a helpful assistant that responds in Markdown."},
-            {"role": "user", "content": [
-                {"type":"text","text":prompt},
-                {"type":"image_url","image_url":{"url":data_uri}}
-            ]}
-        ]
-    )
-    return resp.choices[0].message.content
-
-# 🎤 Audio transcription + chat
-def transcribe_audio_file(api_key, file):
-    openai.api_key = api_key.strip()
-    resp = openai.Audio.transcriptions.create(model="whisper-1", file=file)
-    return resp.text
-
-# 🎥 Video summarize
-def summarize_video(api_key, file, prompt, seconds=2):
-    # save tmp
-    with open("tmp_vid.mp4", 'wb') as f: f.write(file.read())
-    clip = VideoFileClip("tmp_vid.mp4")
-    frames = []
-    step = int(clip.fps * seconds)
-    for t in range(0, int(clip.duration), seconds):
-        frame = clip.get_frame(t)
-        buf = BytesIO()
-        from PIL import Image
-        Image.fromarray(frame).save(buf, format='JPEG')
-        frames.append(base64.b64encode(buf.getvalue()).decode())
-    transcript = transcribe_audio_file(api_key, open("tmp_vid.mp4", 'rb'))
-    openai.api_key = api_key.strip()
-    messages = [{"role":"system","content":"You are a helpful assistant."},
-                {"role":"user","content": prompt}]
-    for f64 in frames:
-        messages.append({"role":"user","content": {"type":"image_url","image_url":{"url":f"data:image/jpeg;base64,{f64}"}}})
-    messages.append({"role":"user","content": f"Transcript: {transcript}"})
-    resp = openai.ChatCompletion.create(model=MODEL, messages=messages)
-    return resp.choices[0].message.content
-
-# 📄 PDF->Markdown
-def pdf_to_markdown(path):
-    doc = fitz.open(path)
-    md = ''
-    for page in doc:
-        md += page.get_text('markdown') + '\n'
-    return md
-
-# 🔍 ArXiv RAG
-from gradio_client import Client
-def arxiv_search(query):
-    client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
-    refs = client.predict(query, 10, "Semantic Search - up to 10 Mar 2024", "mistralai/Mixtral-8x7B-Instruct-v0.1", api_name="/update_with_rag_md")
-    ans = client.predict(query, "mistralai/Mixtral-8x7B-Instruct-v0.1", True, api_name="/ask_llm")
-    return refs + "\n" + ans
-
-# 🔈 TTS
-from gtts import gTTS
-def tts_bytes(text):
-    buf = BytesIO()
-    gTTS(text=text, lang='en').write_to_fp(buf)
-    buf.seek(0)
-    return buf.read()
-
-# UI CONFIG
-ui_config = {
-    "chat": {"label":"💬 ChatGPT-4o", "placeholder":"Say something..."},
-    "image_prompt": {"label":"🖼️ Image Prompt", "default":"Describe this image..."},
-    "audio_prompt": {"label":"🎤 Audio Prompt", "default":"Transcribe and summarize..."},
-    "video_prompt": {"label":"🎥 Video Prompt", "default":"Summarize this video..."},
-    "pdf_prompt": {"label":"📄 PDF Prompt", "default":"Convert PDF to markdown..."},
-    "arxiv_prompt": {"label":"🔍 Arxiv Query", "default":"Search papers..."}
-}
+# 🎞️ Example: Video Summarizer (placeholder)
+# def summarize_video(api_key, file_path, prompt):
+#     ... implementation ...
 
+# 🔑 UI Definition
 with gr.Blocks(title="🔬🧠 ScienceBrain.Gradio") as demo:
-    gr.Markdown("# 🔬🧠 ScienceBrain Gradio\nEnter API key below.")
+    gr.Markdown("# 🔬🧠 ScienceBrain Gradio")
+
     with gr.Row():
-        api_key = gr.Textbox(label="🔑 OpenAI Key", value=DEFAULT_KEY, type="password")
+        api_input = gr.Textbox(label="🔑 OpenAI Key", value=DEFAULT_KEY, type="password")
         save_btn = gr.Button("💾 Save Key")
-        status = gr.Textbox(label="Status", interactive=False)
-    save_btn.click(save_api_key, inputs=api_key, outputs=status)
+        status_txt = gr.Textbox(interactive=False)
+        save_btn.click(save_api_key, inputs=api_input, outputs=status_txt)
+
+    gr.Markdown("## 📋 Media Gallery & Filters")
+    upload = gr.File(file_count="multiple", label="Upload files (images, audio, videos, PDFs)")
+    gallery = gr.Gallery(label="Filtered Gallery").style(grid=[4], height="auto")
+    filter_opts = ["🖼️ Images", "🎤 Audio", "🎥 Video", "📄 PDF"]
+    filters = gr.CheckboxGroup(filter_opts, value=filter_opts, label="🔍 Filter Types")
+    select_btn = gr.Button("⚙️ Apply Filters")
+    selected = gr.Variable()
+    select_btn.click(apply_filters, inputs=[upload, filters], outputs=[gallery, selected])
+
+    gr.Markdown("## ✅ Include in Discussion")
+    disc = gr.CheckboxGroup(label="Select items", choices=[])
+    gallery.select(lambda x: [x], None, disc)
+
+    gr.Markdown("## 📝 Summary Table")
+    table_md = gr.Markdown()
+    table_btn = gr.Button("Generate Table")
+    table_btn.click(generate_table, inputs=[disc, api_input], outputs=table_md)
 
-    # Tabs for each modality
     with gr.Tab("💬 Chat"):
-        chatbot = gr.Chatbot(label=ui_config['chat']['label'], value=[])
-        msg = gr.Textbox(label=ui_config['chat']['label'], placeholder=ui_config['chat']['placeholder'])
-        msg.submit(chat_with_openai, inputs=[api_key, msg, chatbot], outputs=chatbot)
-
-    with gr.Tab("🖼️ Image"):
-        img_in = gr.File(file_types=['png','jpg','jpeg'])
-        img_prompt = gr.Textbox(label=ui_config['image_prompt']['label'], value=ui_config['image_prompt']['default'])
-        img_btn = gr.Button("🔍 Analyze Image")
-        img_out = gr.Markdown()
-        img_btn.click(analyze_image, inputs=[api_key, img_in, img_prompt], outputs=img_out)
-
-    with gr.Tab("🎤 Audio"):
-        aud_in = gr.File(file_types=['wav','mp3'])
-        aud_btn = gr.Button("🔊 Transcribe + Chat")
-        aud_out = gr.Markdown()
-        def audio_pipeline(key, f):
-            text = transcribe_audio_file(key, f)
-            reply = chat_with_openai(key, text, [])[-1][1]
-            return f"**Transcript:** {text}\n\n**Reply:** {reply}"
-        aud_btn.click(audio_pipeline, inputs=[api_key, aud_in], outputs=aud_out)
-
-    with gr.Tab("🎥 Video"):
-        vid_in = gr.File(file_types=['mp4'])
-        vid_prompt = gr.Textbox(label=ui_config['video_prompt']['label'], value=ui_config['video_prompt']['default'])
-        vid_btn = gr.Button("🎞️ Summarize Video")
-        vid_out = gr.Markdown()
-        vid_btn.click(summarize_video, inputs=[api_key, vid_in, vid_prompt], outputs=vid_out)
-
-    with gr.Tab("📄 PDF"):
-        pdf_in = gr.File(file_types=['pdf'])
-        pdf_btn = gr.Button("📝 Convert PDF")
-        pdf_out = gr.Markdown()
-        pdf_btn.click(lambda f: pdf_to_markdown(f.name), inputs=[pdf_in], outputs=pdf_out)
-
-    with gr.Tab("🔍 ArXiv"):
-        arxiv_in = gr.Textbox(label=ui_config['arxiv_prompt']['label'], value=ui_config['arxiv_prompt']['default'])
-        arxiv_btn = gr.Button("🔎 Search ArXiv")
-        arxiv_out = gr.Markdown()
-        arxiv_btn.click(arxiv_search, inputs=[arxiv_in], outputs=arxiv_out)
-
-    with gr.Tab("⚙️ Quick Tests"):
-        tests = [
-            ("📝 Text","What is 2+2?"),
-            ("🖼️ Image","Analyze image https://via.placeholder.com/150.png"),
-            ("🎤 Audio","Transcribe https://www2.cs.uic.edu/~i101/SoundFiles/gettysburg10.wav"),
-            ("🎥 Video","Summarize video https://sample-videos.com/video123/mp4/240/big_buck_bunny_240p_1mb.mp4"),
-            ("🖼️+📝 Img+Txt","Given image https://via.placeholder.com/150.png list 3 facts."),
-            ("🎤+📝 Aud+Txt","Given audio https://www2.cs.uic.edu/~i101/SoundFiles/gettysburg10.wav summarize."),
-            ("🎥+📝 Vid+Txt","Given video https://sample-videos.com/video123/mp4/240/big_buck_bunny_240p_1mb.mp4 transcript+summary.")
-        ]
-        for idx, (e,p) in enumerate(tests,1):
-            btn = gr.Button(f"{idx}. {e} Test")
-            btn.click(chat_with_openai, inputs=[api_key, gr.State(p), gr.State([])], outputs=chatbot)
+        chatbot = gr.Chatbot()
+        msg_in = gr.Textbox(placeholder="Type your message...")
+        msg_in.submit(chat_handler, inputs=[api_input, msg_in, chatbot], outputs=chatbot)
 
 if __name__ == "__main__":
     demo.launch()
+```