ChatStreamlitMultiplayer

Sleeping

App Files Files Community

awacke1 commited on Jul 22, 2024

Commit

9174061

verified ·

1 Parent(s): 93a5e99

Update app.py

Browse files

Files changed (1) hide show

app.py +228 -47

app.py CHANGED Viewed

@@ -1,18 +1,61 @@
-import streamlit as st
-import time
-import random
 import json
-from datetime import datetime
 import pytz
-import platform
 import uuid
 import extra_streamlit_components as stx
-import requests
 from urllib.parse import quote
 from openai import OpenAI
-# Set page config
-st.set_page_config(page_title="Personalized Real-Time Chat with ArXiv Search and AI", page_icon="💬", layout="wide")
 # Initialize cookie manager
 cookie_manager = stx.CookieManager()
@@ -20,6 +63,37 @@ cookie_manager = stx.CookieManager()
 # File to store chat history and user data
 CHAT_FILE = "chat_history.txt"
 # Function to save chat history and user data to file
 def save_data():
     with open(CHAT_FILE, 'w') as f:
@@ -63,13 +137,72 @@ def get_or_create_user():
     return user
-# Initialize session state
-if 'messages' not in st.session_state:
-    st.session_state.messages = []
-if 'users' not in st.session_state:
-    st.session_state.users = []
-if 'current_user' not in st.session_state:
-    st.session_state.current_user = get_or_create_user()
 # ArXiv search function
 def search_arxiv(query):
@@ -88,27 +221,6 @@ def search_arxiv(query):
     else:
         return "Error fetching results from ArXiv."
-# Initialize OpenAI client
-client = OpenAI(api_key=st.secrets['OPENAI_API_KEY'])
-MODEL = "gpt-4-0125-preview"  # Use the appropriate model
-# Function to get AI response
-def get_ai_response(prompt, context=""):
-    try:
-        messages = [
-            {"role": "system", "content": "You are a helpful assistant in a chat room that can also search ArXiv."},
-            {"role": "user", "content": f"Context: {context}\n\nUser Query: {prompt}"}
-        ]
-        response = client.chat.completions.create(
-            model=MODEL,
-            messages=messages,
-            max_tokens=150,
-            temperature=0.7
-        )
-        return response.choices[0].message.content
-    except Exception as e:
-        return f"An error occurred: {str(e)}"
 # Sidebar for user information and settings
 with st.sidebar:
     st.title("User Info")
@@ -138,12 +250,12 @@ for message in st.session_state.messages:
     with st.chat_message(message["role"]):
         st.markdown(message["content"])
-# Input for new message
-if prompt := st.chat_input("Type your message or ArXiv search query:"):
     st.session_state.messages.append({"role": "user", "content": prompt})
     with st.chat_message("user"):
         st.markdown(prompt)
     # Check if it's an ArXiv search query
     if prompt.lower().startswith("arxiv:"):
         query = prompt[6:].strip()
@@ -153,18 +265,29 @@ if prompt := st.chat_input("Type your message or ArXiv search query:"):
                 st.markdown(f"Search results for '{query}':\n\n{search_results}")
                 # Get AI commentary on the search results
-                ai_commentary = get_ai_response(f"Provide a brief analysis of these ArXiv search results: {search_results}")
                 st.markdown(f"\nAI Analysis:\n{ai_commentary}")
         st.session_state.messages.append({"role": "assistant", "content": f"Search results for '{query}':\n\n{search_results}\n\nAI Analysis:\n{ai_commentary}"})
     else:
-        # Get AI response for regular chat
         with st.chat_message("assistant"):
-            with st.spinner("AI is thinking..."):
-                ai_response = get_ai_response(prompt)
-                st.markdown(ai_response)
-        st.session_state.messages.append({"role": "assistant", "content": ai_response})
     save_data()
     st.rerun()
@@ -178,4 +301,62 @@ if 'last_refresh' not in st.session_state:
 if time.time() - st.session_state.last_refresh > 5:  # Refresh every 5 seconds
     st.session_state.last_refresh = time.time()
-    st.rerun()

+import base64
+import cv2
+import glob
 import json
+import math
+import os
 import pytz
+import random
+import re
+import requests
+import streamlit as st
+import streamlit.components.v1 as components
+import textract
+import time
+import zipfile
 import uuid
+import platform
 import extra_streamlit_components as stx
+from audio_recorder_streamlit import audio_recorder
+from bs4 import BeautifulSoup
+from collections import deque
+from datetime import datetime
+from dotenv import load_dotenv
+from gradio_client import Client
+from huggingface_hub import InferenceClient
+from io import BytesIO
+from moviepy.editor import VideoFileClip
+from PIL import Image
+from PyPDF2 import PdfReader
+from templates import bot_template, css, user_template
 from urllib.parse import quote
+from xml.etree import ElementTree as ET
+import openai
 from openai import OpenAI
+# Load environment variables
+load_dotenv()
+# Configuration
+Site_Name = 'Scholarly-Article-Document-Search-With-Memory'
+title = "🔬🧠ScienceBrain.AI"
+helpURL = 'https://huggingface.co/awacke1'
+bugURL = 'https://huggingface.co/spaces/awacke1'
+icons = '🔬'
+st.set_page_config(
+    page_title=title,
+    page_icon=icons,
+    layout="wide",
+    initial_sidebar_state="auto",
+    menu_items={
+        'Get Help': helpURL,
+        'Report a bug': bugURL,
+        'About': title
+    }
+)
 # Initialize cookie manager
 cookie_manager = stx.CookieManager()
 # File to store chat history and user data
 CHAT_FILE = "chat_history.txt"
+# API configurations
+API_URL = 'https://qe55p8afio98s0u3.us-east-1.aws.endpoints.huggingface.cloud'
+API_KEY = st.secrets['API_KEY']
+MODEL1 = "meta-llama/Llama-2-7b-chat-hf"
+MODEL1URL = "https://huggingface.co/meta-llama/Llama-2-7b-chat-hf"
+HF_KEY = st.secrets['HF_KEY']
+headers = {
+    "Authorization": f"Bearer {HF_KEY}",
+    "Content-Type": "application/json"
+}
+# OpenAI client setup
+client = OpenAI(api_key=st.secrets['OPENAI_API_KEY'], organization=st.secrets['OPENAI_ORG_ID'])
+MODEL = "gpt-4-1106-preview"
+# Session state initialization
+if "openai_model" not in st.session_state:
+    st.session_state["openai_model"] = MODEL
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+if "users" not in st.session_state:
+    st.session_state.users = []
+if "current_user" not in st.session_state:
+    st.session_state.current_user = get_or_create_user()
+# Sidebar configurations
+should_save = st.sidebar.checkbox("💾 Save", value=True, help="Save your session data.")
+if st.sidebar.button("Clear Session"):
+    st.session_state.messages = []
 # Function to save chat history and user data to file
 def save_data():
     with open(CHAT_FILE, 'w') as f:
     return user
+# HTML5 based Speech Synthesis (Text to Speech in Browser)
+@st.cache_resource
+def SpeechSynthesis(result):
+    documentHTML5 = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Read It Aloud</title>
+        <script type="text/javascript">
+            function readAloud() {{
+                const text = document.getElementById("textArea").value;
+                const speech = new SpeechSynthesisUtterance(text);
+                window.speechSynthesis.speak(speech);
+            }}
+        </script>
+    </head>
+    <body>
+        <h1>🔊 Read It Aloud</h1>
+        <textarea id="textArea" rows="10" cols="80">{result}</textarea>
+        <br>
+        <button onclick="readAloud()">🔊 Read Aloud</button>
+    </body>
+    </html>
+    """
+    components.html(documentHTML5, width=1280, height=300)
+# Function to generate filename
+def generate_filename(prompt, file_type):
+    central = pytz.timezone('US/Central')
+    safe_date_time = datetime.now(central).strftime("%m%d_%H%M")
+    replaced_prompt = prompt.replace(" ", "_").replace("\n", "_")
+    safe_prompt = "".join(x for x in replaced_prompt if x.isalnum() or x == "_")[:240]
+    return f"{safe_date_time}_{safe_prompt}.{file_type}"
+# Function to process text
+def process_text(text_input):
+    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"):
+            message_placeholder = st.empty()
+            full_response = ""
+            for response in client.chat.completions.create(
+                model=st.session_state["openai_model"],
+                messages=[
+                    {"role": m["role"], "content": m["content"]}
+                    for m in st.session_state.messages
+                ],
+                stream=True,
+            ):
+                full_response += (response.choices[0].delta.content or "")
+                message_placeholder.markdown(full_response + "▌")
+            message_placeholder.markdown(full_response)
+        st.session_state.messages.append({"role": "assistant", "content": full_response})
+        filename = generate_filename(text_input, "md")
+        create_file(filename, text_input, full_response, should_save)
+        return full_response
+# Function to create file
+def create_file(filename, prompt, response, should_save=True):
+    if should_save:
+        with open(filename, "w", encoding="utf-8") as f:
+            f.write(prompt + "\n\n" + response)
 # ArXiv search function
 def search_arxiv(query):
     else:
         return "Error fetching results from ArXiv."
 # Sidebar for user information and settings
 with st.sidebar:
     st.title("User Info")
     with st.chat_message(message["role"]):
         st.markdown(message["content"])
+# Chat input
+if prompt := st.chat_input("What would you like to know?"):
     st.session_state.messages.append({"role": "user", "content": prompt})
     with st.chat_message("user"):
         st.markdown(prompt)
     # Check if it's an ArXiv search query
     if prompt.lower().startswith("arxiv:"):
         query = prompt[6:].strip()
                 st.markdown(f"Search results for '{query}':\n\n{search_results}")
                 # Get AI commentary on the search results
+                ai_commentary = process_text(f"Provide a brief analysis of these ArXiv search results: {search_results}")
                 st.markdown(f"\nAI Analysis:\n{ai_commentary}")
         st.session_state.messages.append({"role": "assistant", "content": f"Search results for '{query}':\n\n{search_results}\n\nAI Analysis:\n{ai_commentary}"})
     else:
+        # Regular chat processing
         with st.chat_message("assistant"):
+            message_placeholder = st.empty()
+            full_response = ""
+            for response in client.chat.completions.create(
+                model=st.session_state["openai_model"],
+                messages=[
+                    {"role": m["role"], "content": m["content"]}
+                    for m in st.session_state.messages
+                ],
+                stream=True,
+            ):
+                full_response += (response.choices[0].delta.content or "")
+                message_placeholder.markdown(full_response + "▌")
+            message_placeholder.markdown(full_response)
+        st.session_state.messages.append({"role": "assistant", "content": full_response})
     save_data()
     st.rerun()
 if time.time() - st.session_state.last_refresh > 5:  # Refresh every 5 seconds
     st.session_state.last_refresh = time.time()
+    st.rerun()
+# Main function to handle different input types
+def main():
+    st.markdown("##### GPT-4 Multimodal AI Assistant: Text, Audio, Image, & Video")
+    option = st.selectbox("Select an option", ("Text", "Image", "Audio", "Video"))
+    if option == "Text":
+        text_input = st.text_input("Enter your text:")
+        if text_input:
+            process_text(text_input)
+    elif option == "Image":
+        text = "Help me understand what is in this picture and list ten facts as markdown outline with appropriate emojis that describes what you see."
+        text_input = st.text_input(label="Enter text prompt to use with Image context.", value=text)
+        image_input = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg"])
+        if image_input:
+            image = Image.open(image_input)
+            st.image(image, caption="Uploaded Image", use_column_width=True)
+            if st.button("Analyze Image"):
+                with st.spinner("Analyzing..."):
+                    image_byte_arr = BytesIO()
+                    image.save(image_byte_arr, format='PNG')
+                    image_byte_arr = image_byte_arr.getvalue()
+                    response = client.chat.completions.create(
+                        model="gpt-4-vision-preview",
+                        messages=[
+                            {
+                                "role": "user",
+                                "content": [
+                                    {"type": "text", "text": text_input},
+                                    {
+                                        "type": "image_url",
+                                        "image_url": {
+                                            "url": f"data:image/jpeg;base64,{base64.b64encode(image_byte_arr).decode()}"
+                                        }
+                                    },
+                                ],
+                            }
+                        ],
+                        max_tokens=300,
+                    )
+                    st.write(response.choices[0].message.content)
+    elif option == "Audio":
+        text = "You are generating a transcript summary. Create a summary of the provided transcription. Respond in Markdown."
+        text_input = st.text_input(label="Enter text prompt to use with Audio context.", value=text)
+        audio_file = st.file_uploader("Upload an audio file", type=["mp3", "wav"])
+        if audio_file:
+            if st.button("Transcribe Audio"):
+                with st.spinner("Transcribing..."):
+                    transcription = client.audio.transcriptions.create(
+                        model="whisper-1",
+                        file=audio_file
+                    )
+                    st.write(transcription.text)
+                    st.session_state.messages.append({"role": "user", "content": f"Transcription: {transcription.text}"})
+                    process_text(f"{text}\n\nTranscription: {transcription.text}")