Update app.py

app.py

@@ -1,6 +1,6 @@
 import streamlit as st
 import anthropic
-import openai 
+import openai
 import base64
 from datetime import datetime
 import plotly.graph_objects as go
@@ -32,8 +32,8 @@ from xml.etree import ElementTree as ET
 from openai import OpenAI
 
 # Configuration and Setup
-Site_Name = '🤖🧠Claude35📝🔬'
-title = "🤖🧠Claude35📝🔬"
+Site_Name = '🤖🧠Combined AI App📝🔬'
+title = "🤖🧠Combined AI App📝🔬"
 helpURL = 'https://huggingface.co/awacke1'
 bugURL = 'https://huggingface.co/spaces/awacke1'
 icons = '🤖🧠🔬📝'
@@ -69,26 +69,21 @@ if anthropic_key == None:
     anthropic_key = st.secrets["ANTHROPIC_API_KEY"]
 claude_client = anthropic.Anthropic(api_key=anthropic_key)
 
-# HuggingFace setup
-API_URL = os.getenv('API_URL')
-HF_KEY = os.getenv('HF_KEY')
-MODEL1 = "meta-llama/Llama-2-7b-chat-hf"
-MODEL2 = "openai/whisper-small.en"
-
-headers = {
-    "Authorization": f"Bearer {HF_KEY}",
-    "Content-Type": "application/json"
-}
-
 # Initialize session states
 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"
+    st.session_state["openai_model"] = "gpt-4"
 if "messages" not in st.session_state:
     st.session_state.messages = []
 if "search_queries" not in st.session_state:
     st.session_state.search_queries = []
+if 'selected_file' not in st.session_state:
+    st.session_state.selected_file = None
+if 'view_mode' not in st.session_state:
+    st.session_state.view_mode = 'view'
+if 'files' not in st.session_state:
+    st.session_state.files = []
 
 # Custom CSS
 st.markdown("""
@@ -183,8 +178,10 @@ bike_collections = {
 }
 
 # File Operations Functions
-def create_file(filename, prompt, response, is_image=False):
+def create_file(filename, prompt, response, is_image=False, should_save=True):
     """Basic file creation with prompt and response."""
+    if not should_save:
+        return None
     with open(filename, "w", encoding="utf-8") as f:
         f.write(prompt + "\n\n" + response)
 
@@ -274,12 +271,13 @@ def SpeechSynthesis(result):
     '''
     components.html(documentHTML5, width=1280, height=300)
 
-# ArXiv Search Functions
-def search_arxiv(query):
+# ArXiv Search Functions (Combined into one function)
+def search_arxiv(query, should_save=True):
     """Search ArXiv papers using Hugging Face client."""
-    start_time = time.strftime("%Y-%m-%d %H:%M:%S")
+    st.write("Performing AI Lookup...")
     client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
-    
+    start_time = time.strftime("%Y-%m-%d %H:%M:%S")
+
     # First query - Get papers
     response1 = client.predict(
         query,
@@ -288,7 +286,7 @@ def search_arxiv(query):
         "mistralai/Mixtral-8x7B-Instruct-v0.1",
         api_name="/update_with_rag_md"
     )
-    
+
     # Second query - Get summary
     response2 = client.predict(
         query,
@@ -296,26 +294,27 @@ def search_arxiv(query):
         True,
         api_name="/ask_llm"
     )
-    
+
     Question = '### 🔎 ' + query + '\r\n'
     References = response1[0]
-    References2 = response1[1]
     ReferenceLinks = extract_urls(References)
-    
-    filename = generate_filename(query, "md")
-    create_file(filename, query, References + ReferenceLinks)
-    
+
     results = Question + '\r\n' + response2 + '\r\n' + References + '\r\n' + ReferenceLinks
-    
+
+    st.markdown(results)
+    SpeechSynthesis(results)
+
     end_time = time.strftime("%Y-%m-%d %H:%M:%S")
     start_timestamp = time.mktime(time.strptime(start_time, "%Y-%m-%d %H:%M:%S"))
     end_timestamp = time.mktime(time.strptime(end_time, "%Y-%m-%d %H:%M:%S"))
     elapsed_seconds = end_timestamp - start_timestamp
-    
+
     st.write(f"Start time: {start_time}")
     st.write(f"Finish time: {end_time}")
     st.write(f"Elapsed time: {elapsed_seconds:.2f} seconds")
-    
+
+    filename = generate_filename(query, "md")
+    create_file(filename, query, results, should_save=should_save)
     return results
 
 def extract_urls(text):
@@ -325,7 +324,7 @@ def extract_urls(text):
         abs_link_pattern = re.compile(r'\[(.*?)\]\((https://arxiv\.org/abs/\d+\.\d+)\)')
         pdf_link_pattern = re.compile(r'\[⬇️\]\((https://arxiv\.org/pdf/\d+\.\d+)\)')
         title_pattern = re.compile(r'### \d{2} \w{3} \d{4} \| \[(.*?)\]')
-        
+
         date_matches = date_pattern.findall(text)
         abs_link_matches = abs_link_pattern.findall(text)
         pdf_link_matches = pdf_link_pattern.findall(text)
@@ -349,16 +348,14 @@ def extract_urls(text):
 
 # Media Processing Functions
 def process_image(image_input, user_prompt):
-    """Process image with GPT-4o vision."""
+    """Process image with GPT-4 vision."""
     if isinstance(image_input, str):
         with open(image_input, "rb") as image_file:
             image_input = image_file.read()
-            
-    base64_image = base64.b64encode(image_input).decode("utf-8")
-    
 
+    base64_image = base64.b64encode(image_input).decode("utf-8")
 
-    response = openai_client.chat.completions.create(
+    response = openai.ChatCompletion.create(
         model=st.session_state["openai_model"],
         messages=[
             {"role": "system", "content": "You are a helpful assistant that responds in Markdown."},
@@ -371,7 +368,7 @@ def process_image(image_input, user_prompt):
         ],
         temperature=0.0,
     )
-    
+
     return response.choices[0].message.content
 
 def process_audio(audio_input, text_input=''):
@@ -380,17 +377,17 @@ def process_audio(audio_input, text_input=''):
         with open(audio_input, "rb") as file:
             audio_input = file.read()
 
-    transcription = openai_client.audio.transcriptions.create(
+    transcription = openai.Audio.transcribe(
         model="whisper-1",
         file=audio_input,
     )
-    
+
     st.session_state.messages.append({"role": "user", "content": transcription.text})
-    
+
     with st.chat_message("assistant"):
         st.markdown(transcription.text)
         SpeechSynthesis(transcription.text)
-        
+
         filename = generate_filename(transcription.text, "wav")
         create_and_save_file(audio_input, "wav", transcription.text, True)
 
@@ -412,7 +409,7 @@ def process_video(video_path, seconds_per_frame=1):
     total_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
     fps = video.get(cv2.CAP_PROP_FPS)
     frames_to_skip = int(fps * seconds_per_frame)
-    
+
     for frame_idx in range(0, total_frames, frames_to_skip):
         video.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
         success, frame = video.read()
@@ -420,9 +417,9 @@ def process_video(video_path, seconds_per_frame=1):
             break
         _, buffer = cv2.imencode(".jpg", frame)
         base64Frames.append(base64.b64encode(buffer).decode("utf-8"))
-    
+
     video.release()
-    
+
     # Extract audio
     base_video_path = os.path.splitext(video_path)[0]
     audio_path = f"{base_video_path}.mp3"
@@ -433,14 +430,14 @@ def process_video(video_path, seconds_per_frame=1):
     except:
         st.warning("No audio track found in video")
         audio_path = None
-    
+
     return base64Frames, audio_path
 
 def process_video_with_gpt(video_input, user_prompt):
-    """Process video with GPT-4o vision."""
+    """Process video with GPT-4 vision."""
     base64Frames, audio_path = process_video(video_input)
-    
-    response = openai_client.chat.completions.create(
+
+    response = openai.ChatCompletion.create(
         model=st.session_state["openai_model"],
         messages=[
             {"role": "system", "content": "Analyze the video frames and provide a detailed description."},
@@ -451,15 +448,15 @@ def process_video_with_gpt(video_input, user_prompt):
             ]}
         ]
     )
-    
+
     return response.choices[0].message.content
 
 def create_media_gallery():
     """Create the media gallery interface."""
     st.header("🎬 Media Gallery")
-    
+
     tabs = st.tabs(["🖼️ Images", "🎵 Audio", "🎥 Video", "🎨 Scene Generator"])
-    
+
     with tabs[0]:  # Images
         image_files = glob.glob("*.png") + glob.glob("*.jpg")
         if image_files:
@@ -469,13 +466,13 @@ def create_media_gallery():
                 with cols[idx % num_cols]:
                     img = Image.open(image_file)
                     st.image(img, use_column_width=True)
-                    
+
                     if st.button(f"Analyze {os.path.basename(image_file)}"):
-                        analysis = process_image(image_file, 
+                        analysis = process_image(image_file,
                                               "Describe this image in detail and identify key elements.")
                         st.markdown(analysis)
                         SpeechSynthesis(analysis)
-    
+
     with tabs[1]:  # Audio
         audio_files = glob.glob("*.mp3") + glob.glob("*.wav")
         for audio_file in audio_files:
@@ -486,23 +483,23 @@ def create_media_gallery():
                         transcription = process_audio(f)
                         st.write(transcription)
                         SpeechSynthesis(transcription)
-    
+
     with tabs[2]:  # Video
         video_files = glob.glob("*.mp4")
         for video_file in video_files:
             with st.expander(f"🎥 {os.path.basename(video_file)}"):
                 st.markdown(get_media_html(video_file, "video"), unsafe_allow_html=True)
                 if st.button(f"Analyze {os.path.basename(video_file)}"):
-                    analysis = process_video_with_gpt(video_file, 
+                    analysis = process_video_with_gpt(video_file,
                                                     "Describe what's happening in this video.")
                     st.markdown(analysis)
                     SpeechSynthesis(analysis)
-    
+
     with tabs[3]:  # Scene Generator
         for collection_name, bikes in bike_collections.items():
             st.subheader(collection_name)
             cols = st.columns(len(bikes))
-            
+
             for idx, (bike_name, details) in enumerate(bikes.items()):
                 with cols[idx]:
                     st.markdown(f"""
@@ -511,7 +508,7 @@ def create_media_gallery():
                         <p>{details['prompt']}</p>
                     </div>
                     """, unsafe_allow_html=True)
-                    
+
                     if st.button(f"Generate {bike_name} Scene"):
                         prompt = details['prompt']
                         st.write(f"Generated scene description for {bike_name}:")
@@ -519,16 +516,16 @@ def create_media_gallery():
                         SpeechSynthesis(prompt)
 
 # Chat Processing Functions
-def process_with_gpt(text_input):
-    """Process text with GPT-4o."""
+def process_with_gpt(text_input, should_save=True):
+    """Process text with GPT-4."""
     if text_input:
         st.session_state.messages.append({"role": "user", "content": text_input})
-        
+
         with st.chat_message("user"):
             st.markdown(text_input)
-        
+
         with st.chat_message("assistant"):
-            completion = openai_client.chat.completions.create(
+            completion = openai.ChatCompletion.create(
                 model=st.session_state["openai_model"],
                 messages=[
                     {"role": m["role"], "content": m["content"]}
@@ -537,29 +534,27 @@ def process_with_gpt(text_input):
                 stream=False
             )
             return_text = completion.choices[0].message.content
-            st.write("GPT-4o: " + return_text)
-            
+            st.write("GPT-4: " + return_text)
+
             filename = generate_filename(text_input, "md")
-            create_file(filename, text_input, return_text)
+            create_file(filename, text_input, return_text, should_save=should_save)
             st.session_state.messages.append({"role": "assistant", "content": return_text})
             return return_text
 
-def process_with_claude(text_input):
+def process_with_claude(text_input, should_save=True):
     """Process text with Claude."""
     if text_input:
-        response = claude_client.messages.create(
-            model="claude-3-sonnet-20240229",
-            max_tokens=1000,
-            messages=[
-                {"role": "user", "content": text_input}
-            ]
+        response = claude_client.completions.create(
+            model="claude-2",
+            max_tokens_to_sample=1000,
+            prompt=text_input
         )
-        response_text = response.content[0].text
+        response_text = response.completion
         st.write("Claude: " + response_text)
-        
+
         filename = generate_filename(text_input, "md")
-        create_file(filename, text_input, response_text)
-        
+        create_file(filename, text_input, response_text, should_save=should_save)
+
         st.session_state.chat_history.append({
             "user": text_input,
             "claude": response_text
@@ -569,7 +564,7 @@ def process_with_claude(text_input):
 def display_file_manager():
     """Display file management sidebar."""
     st.sidebar.title("📁 File Management")
-    
+
     all_files = glob.glob("*.md")
     all_files.sort(reverse=True)
 
@@ -586,95 +581,106 @@ def display_file_manager():
         col1, col2, col3, col4 = st.sidebar.columns([1,3,1,1])
         with col1:
             if st.button("🌐", key="view_"+file):
-                st.session_state.current_file = file
+                st.session_state.selected_file = file
                 st.session_state.file_content = load_file(file)
                 SpeechSynthesis(st.session_state.file_content)
         with col2:
             st.markdown(get_download_link(file), unsafe_allow_html=True)
         with col3:
             if st.button("📂", key="edit_"+file):
-                st.session_state.current_file = file
+                st.session_state.selected_file = file
                 st.session_state.file_content = load_file(file)
         with col4:
             if st.button("🗑", key="delete_"+file):
                 os.remove(file)
                 st.rerun()
 
+def display_file_content(file_path):
+    """Display file content with editing capabilities."""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+
+        if st.session_state.view_mode == 'view':
+            st.markdown(content)
+        else:
+            edited_content = st.text_area(
+                "Edit content",
+                content,
+                height=400,
+                key=f"edit_{os.path.basename(file_path)}"
+            )
+
+            if st.button("Save Changes", key=f"save_{os.path.basename(file_path)}"):
+                try:
+                    with open(file_path, 'w', encoding='utf-8') as f:
+                        f.write(edited_content)
+                    st.success(f"Successfully saved changes to {file_path}")
+                except Exception as e:
+                    st.error(f"Error saving changes: {e}")
+    except Exception as e:
+        st.error(f"Error reading file: {e}")
+
 def main():
-    st.title("🚲 Bike Cinematic Universe & AI Assistant")
-    
-    # Main navigation
-    tab_main = st.radio("Choose Action:", 
-                        ["💬 Chat", "📸 Media Gallery", "🔍 Search ArXiv", "📝 File Editor"],
-                        horizontal=True)
-    
-    if tab_main == "💬 Chat":
-        # Model Selection
-        model_choice = st.sidebar.radio(
-            "Choose AI Model:",
-            ["GPT-4o", "Claude-3", "Both"]
-        )
-        
-        # Chat Interface
+    st.title("🚀 Combined AI Assistant App")
+
+    # Main navigation with radio buttons
+    ai_options = ["💬 Chat with GPT-4", "💬 Chat with Claude", "🔍 Search ArXiv", "📸 Media Gallery", "📝 File Editor"]
+    tab_main = st.radio("Choose Action:", ai_options, horizontal=True)
+
+    if tab_main == "💬 Chat with GPT-4":
         user_input = st.text_area("Message:", height=100)
-        
         if st.button("Send 📨"):
             if user_input:
-                if model_choice == "GPT-4o":
-                    gpt_response = process_with_gpt(user_input)
-                    SpeechSynthesis(gpt_response)
-                elif model_choice == "Claude-3":
-                    claude_response = process_with_claude(user_input)
-                    SpeechSynthesis(claude_response)
-                else:  # Both
-                    col1, col2 = st.columns(2)
-                    with col1:
-                        st.subheader("GPT-4o Response")
-                        gpt_response = process_with_gpt(user_input)
-                        SpeechSynthesis(gpt_response)
-                    with col2:
-                        st.subheader("Claude-3 Response")
-                        claude_response = process_with_claude(user_input)
-                        SpeechSynthesis(claude_response)
-        
+                gpt_response = process_with_gpt(user_input)
+                SpeechSynthesis(gpt_response)
+
         # Display Chat History
         st.subheader("Chat History 📜")
-        tab1, tab2 = st.tabs(["Claude History", "GPT-4o History"])
-        
-        with tab1:
-            for chat in st.session_state.chat_history:
-                st.text_area("You:", chat["user"], height=100, disabled=True)
-                st.text_area("Claude:", chat["claude"], height=200, disabled=True)
-                st.markdown("---")
-        
-        with tab2:
-            for message in st.session_state.messages:
-                with st.chat_message(message["role"]):
-                    st.markdown(message["content"])
-    
-    elif tab_main == "📸 Media Gallery":
-        create_media_gallery()
-    
+        for message in st.session_state.messages:
+            with st.chat_message(message["role"]):
+                st.markdown(message["content"])
+
+    elif tab_main == "💬 Chat with Claude":
+        user_input = st.text_area("Message:", height=100)
+        if st.button("Send 📨"):
+            if user_input:
+                claude_response = process_with_claude(user_input)
+                SpeechSynthesis(claude_response)
+
+        # Display Chat History
+        st.subheader("Chat History 📜")
+        for chat in st.session_state.chat_history:
+            st.text_area("You:", chat["user"], height=100, disabled=True)
+            st.text_area("Claude:", chat["claude"], height=200, disabled=True)
+            st.markdown("---")
+
     elif tab_main == "🔍 Search ArXiv":
-        query = st.text_input("Enter your research query:")
+        query_params = st.experimental_get_query_params()
+        query = query_params.get('q', [''])[0]
+        query = st.text_input("Enter your research query:", value=query)
         if query:
             with st.spinner("Searching ArXiv..."):
                 results = search_arxiv(query)
-                st.markdown(results)
+                # Save the query and results
+                filename = generate_filename(query, "md")
+                create_file(filename, query, results)
+                st.session_state.selected_file = filename
+                st.session_state.file_content = results
                 SpeechSynthesis(results)
-    
+
+    elif tab_main == "📸 Media Gallery":
+        create_media_gallery()
+
     elif tab_main == "📝 File Editor":
-        if hasattr(st.session_state, 'current_file'):
-            st.subheader(f"Editing: {st.session_state.current_file}")
-            new_content = st.text_area("Content:", st.session_state.file_content, height=300)
-            if st.button("Save Changes"):
-                with open(st.session_state.current_file, 'w', encoding='utf-8') as file:
-                    file.write(new_content)
-                st.success("File updated successfully!")
-                SpeechSynthesis("File updated successfully!")
+        if st.session_state.selected_file:
+            st.subheader(f"Editing: {st.session_state.selected_file}")
+            display_file_content(st.session_state.selected_file)
+        else:
+            st.write("No file selected.")
 
     # Always show file manager in sidebar
     display_file_manager()
 
 if __name__ == "__main__":
-    main()
+    main()