import streamlit as st
import streamlit.components.v1 as components
import openai
import os
import base64
import glob
import io
import json
import mistune
import pytz
import math
import requests
import sys
import time
import re
import textract
import zipfile # New import for zipping files
import random
from datetime import datetime
from openai import ChatCompletion
from xml.etree import ElementTree as ET
from bs4 import BeautifulSoup
from collections import deque
from audio_recorder_streamlit import audio_recorder
from dotenv import load_dotenv
from PyPDF2 import PdfReader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationalRetrievalChain
from templates import css, bot_template, user_template
# page config and sidebar declares up front allow all other functions to see global class variables
st.set_page_config(page_title="GPT Streamlit Document Reasoner", layout="wide")
should_save = st.sidebar.checkbox("๐พ Save", value=True)
# LLM engines for ChatCompletion and Chat with files
def chat_with_model(prompt, document_section, model_choice='gpt-3.5-turbo'):
model = model_choice
conversation = [{'role': 'system', 'content': 'You are a helpful assistant.'}]
conversation.append({'role': 'user', 'content': prompt})
if len(document_section)>0:
conversation.append({'role': 'assistant', 'content': document_section})
start_time = time.time()
report = []
res_box = st.empty()
collected_chunks = []
collected_messages = []
key = os.getenv('OPENAI_API_KEY')
openai.api_key = key
for chunk in openai.ChatCompletion.create(
model='gpt-3.5-turbo',
messages=conversation,
temperature=0.5,
stream=True
):
collected_chunks.append(chunk) # save the event response
chunk_message = chunk['choices'][0]['delta'] # extract the message
collected_messages.append(chunk_message) # save the message
content=chunk["choices"][0].get("delta",{}).get("content")
try:
report.append(content)
if len(content) > 0:
result = "".join(report).strip()
#result = result.replace("\n", "")
res_box.markdown(f'*{result}*')
except:
st.write(' ')
full_reply_content = ''.join([m.get('content', '') for m in collected_messages])
st.write("Elapsed time:")
st.write(time.time() - start_time)
readitaloud(full_reply_content)
return full_reply_content
def chat_with_file_contents(prompt, file_content, model_choice='gpt-3.5-turbo'):
conversation = [{'role': 'system', 'content': 'You are a helpful assistant.'}]
conversation.append({'role': 'user', 'content': prompt})
if len(file_content)>0:
conversation.append({'role': 'assistant', 'content': file_content})
response = openai.ChatCompletion.create(model=model_choice, messages=conversation)
return response['choices'][0]['message']['content']
def link_button_with_emoji(url, title, emoji_summary):
emojis = ["๐", "๐ฅ", "๐ก๏ธ", "๐ฉบ", "๐ก๏ธ", "๐ฌ", "๐", "๐งช", "๐จโโ๏ธ", "๐ฉโโ๏ธ"]
random_emoji = random.choice(emojis)
st.markdown(f"[{random_emoji} {emoji_summary} - {title}]({url})")
# MemGPT Paper
url_memgpt = "https://arxiv.org/abs/2310.08560"
title_memgpt = "MemGPT"
emoji_summary_memgpt = "๐ง ๐พ Memory OS"
link_button_with_emoji(url_memgpt, title_memgpt, emoji_summary_memgpt)
# AutoGen Paper
url_autogen = "https://arxiv.org/abs/2308.08155"
title_autogen = "AutoGen"
emoji_summary_autogen = "๐ค๐ Multi-Agent LLM"
link_button_with_emoji(url_autogen, title_autogen, emoji_summary_autogen)
# Whisper Paper
url_whisper = "https://arxiv.org/abs/2212.04356"
title_whisper = "Whisper"
emoji_summary_whisper = "๐๐งโ๐ Robust STT"
link_button_with_emoji(url_whisper, title_whisper, emoji_summary_whisper)
# ChatDev Paper
url_chatdev = "https://arxiv.org/pdf/2307.07924.pdf"
title_chatdev = "ChatDev"
emoji_summary_chatdev = "๐ฌ๐ป Comm. Agents"
link_button_with_emoji(url_chatdev, title_chatdev, emoji_summary_chatdev)
# 2. Paper Interface with LLM
def add_paper_buttons():
# Expander for MemGPT
with st.expander("MemGPT ๐ง ๐พ", expanded=False):
if st.button("Discuss MemGPT Features"):
outline_memgpt = "Memory Hierarchy, Context Paging, Self-directed Memory Updates, Memory Editing, Memory Retrieval, Semantic & Episodic Memory, Emotional Contextual Understanding"
chat_with_model("Discuss the key features of MemGPT: " + outline_memgpt, "MemGPT")
# Expander for AutoGen
with st.expander("AutoGen ๐ค๐", expanded=False):
if st.button("Explore AutoGen Multi-Agent LLM"):
outline_autogen = "Cooperative Conversations, Combining Capabilities, Complex Task Solving, Divergent Thinking, Factuality, Highly Capable Agents, Generic Abstraction"
chat_with_model("Explore the key features of AutoGen: " + outline_autogen, "AutoGen")
# Expander for Whisper
with st.expander("Whisper ๐๐งโ๐", expanded=False):
if st.button("Learn About Whisper STT"):
outline_whisper = "Scaling, Deep Learning Approaches, Weak Supervision, Zero-shot Transfer Learning, Accuracy & Robustness, Pre-training Techniques, Broad Environments"
chat_with_model("Learn about the key features of Whisper: " + outline_whisper, "Whisper")
# Expander for ChatDev
with st.expander("ChatDev ๐ฌ๐ป", expanded=False):
if st.button("Deep Dive into ChatDev"):
outline_chatdev = "Effective Communication, Comprehensive Software Solutions, Diverse Social Identities, Tailored Codes, Environment Dependencies, User Manuals"
chat_with_model("Deep dive into the features of ChatDev: " + outline_chatdev, "ChatDev")
add_paper_buttons()
def generate_filename_old(prompt, file_type):
central = pytz.timezone('US/Central')
safe_date_time = datetime.now(central).strftime("%m%d_%H%M") # Date and time DD-HHMM
safe_prompt = "".join(x for x in prompt if x.isalnum())[:90] # Limit file name size and trim whitespace
return f"{safe_date_time}_{safe_prompt}.{file_type}" # Return a safe file name
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 == "_")[:90]
return f"{safe_date_time}_{safe_prompt}.{file_type}"
def transcribe_audio(file_path, model):
key = os.getenv('OPENAI_API_KEY')
headers = {
"Authorization": f"Bearer {key}",
}
with open(file_path, 'rb') as f:
data = {'file': f}
st.write("Read file {file_path}", file_path)
OPENAI_API_URL = "https://api.openai.com/v1/audio/transcriptions"
response = requests.post(OPENAI_API_URL, headers=headers, files=data, data={'model': model})
if response.status_code == 200:
st.write(response.json())
chatResponse = chat_with_model(response.json().get('text'), '') # *************************************
transcript = response.json().get('text')
#st.write('Responses:')
#st.write(chatResponse)
filename = generate_filename(transcript, 'txt')
#create_file(filename, transcript, chatResponse)
response = chatResponse
user_prompt = transcript
create_file(filename, user_prompt, response, should_save)
return transcript
else:
st.write(response.json())
st.error("Error in API call.")
return None
def save_and_play_audio(audio_recorder):
audio_bytes = audio_recorder()
if audio_bytes:
filename = generate_filename("Recording", "wav")
with open(filename, 'wb') as f:
f.write(audio_bytes)
st.audio(audio_bytes, format="audio/wav")
return filename
return None
# Define a context dictionary to maintain the state between exec calls
context = {}
def create_file(filename, prompt, response, should_save=True):
if not should_save:
return
# Extract base filename without extension
base_filename, ext = os.path.splitext(filename)
# Initialize the combined content
combined_content = ""
# Add Prompt with markdown title and emoji
combined_content += "# Prompt ๐\n" + prompt + "\n\n"
# Add Response with markdown title and emoji
combined_content += "# Response ๐ฌ\n" + response + "\n\n"
# Check for code blocks in the response
resources = re.findall(r"```([\s\S]*?)```", response)
for resource in resources:
# Check if the resource contains Python code
if "python" in resource.lower():
# Remove the 'python' keyword from the code block
cleaned_code = re.sub(r'^\s*python', '', resource, flags=re.IGNORECASE | re.MULTILINE)
# Add Code Results title with markdown and emoji
combined_content += "# Code Results ๐\n"
# Redirect standard output to capture it
original_stdout = sys.stdout
sys.stdout = io.StringIO()
# Execute the cleaned Python code within the context
try:
exec(cleaned_code, context)
code_output = sys.stdout.getvalue()
combined_content += f"```\n{code_output}\n```\n\n"
realtimeEvalResponse = "# Code Results ๐\n" + "```" + code_output + "```\n\n"
st.write(realtimeEvalResponse)
except Exception as e:
combined_content += f"```python\nError executing Python code: {e}\n```\n\n"
# Restore the original standard output
sys.stdout = original_stdout
else:
# Add non-Python resources with markdown and emoji
combined_content += "# Resource ๐ ๏ธ\n" + "```" + resource + "```\n\n"
# Save the combined content to a Markdown file
if should_save:
with open(f"{base_filename}-Combined.md", 'w') as file:
file.write(combined_content)
def create_file_old2(filename, prompt, response, should_save=True):
if not should_save:
return
# Step 2: Extract base filename without extension
base_filename, ext = os.path.splitext(filename)
# Step 3: Check if the response contains Python code
has_python_code = bool(re.search(r"```python([\s\S]*?)```", response))
# Step 4: Initialize the combined content
combined_content = ""
# Add Prompt with markdown title and emoji
combined_content += "# Prompt ๐\n" + prompt + "\n\n"
# Add Response with markdown title and emoji
combined_content += "# Response ๐ฌ\n" + response + "\n\n"
# Check for Python code or other resources and add them with markdown title and emoji
resources = re.findall(r"```([\s\S]*?)```", response)
for resource in resources:
# Check if the resource contains Python code
if "python" in resource.lower():
st.markdown('# Running python.. ')
# Remove the word 'python' from the beginning of the code block
cleaned_code = re.sub(r'^\s*python', '', resource, flags=re.IGNORECASE | re.MULTILINE)
# Add Code Results title with markdown and emoji
combined_content += "# Code Results ๐\n"
# Capture standard output
original_stdout = sys.stdout
sys.stdout = io.StringIO()
# Execute cleaned Python code and capture the output
try:
st.markdown('# Running exec.. ')
exec(cleaned_code)
code_output = sys.stdout.getvalue()
combined_content += f"```\n{code_output}\n```\n\n"
realtimeEvalResponse = "# Code Results ๐\n" + "```" + code_output + "```\n\n"
st.write(realtimeEvalResponse)
st.markdown('# Completed exec.. ')
except Exception as e:
combined_content += f"```python\nError executing Python code: {e}\n```\n\n"
st.markdown('# Error in exec.. ' + combined_content)
# Restore the original standard output
sys.stdout = original_stdout
else:
# Add Resource title with markdown and emoji for non-Python resources
combined_content += "# Resource ๐ ๏ธ\n" + "```" + resource + "```\n\n"
# Write the combined content into one file
with open(f"{base_filename}-Combined.md", 'w') as file:
file.write(combined_content)
def truncate_document(document, length):
return document[:length]
def divide_document(document, max_length):
return [document[i:i+max_length] for i in range(0, len(document), max_length)]
def get_table_download_link(file_path):
with open(file_path, 'r') as file:
try:
data = file.read()
except:
st.write('')
return file_path
b64 = base64.b64encode(data.encode()).decode()
file_name = os.path.basename(file_path)
ext = os.path.splitext(file_name)[1] # get the file extension
if ext == '.txt':
mime_type = 'text/plain'
elif ext == '.py':
mime_type = 'text/plain'
elif ext == '.xlsx':
mime_type = 'text/plain'
elif ext == '.csv':
mime_type = 'text/plain'
elif ext == '.htm':
mime_type = 'text/html'
elif ext == '.md':
mime_type = 'text/markdown'
else:
mime_type = 'application/octet-stream' # general binary data type
href = f'{file_name}'
return href
def CompressXML(xml_text):
root = ET.fromstring(xml_text)
for elem in list(root.iter()):
if isinstance(elem.tag, str) and 'Comment' in elem.tag:
elem.parent.remove(elem)
return ET.tostring(root, encoding='unicode', method="xml")
def read_file_content(file,max_length):
if file.type == "application/json":
content = json.load(file)
return str(content)
elif file.type == "text/html" or file.type == "text/htm":
content = BeautifulSoup(file, "html.parser")
return content.text
elif file.type == "application/xml" or file.type == "text/xml":
tree = ET.parse(file)
root = tree.getroot()
xml = CompressXML(ET.tostring(root, encoding='unicode'))
return xml
elif file.type == "text/markdown" or file.type == "text/md":
md = mistune.create_markdown()
content = md(file.read().decode())
return content
elif file.type == "text/plain":
return file.getvalue().decode()
else:
return ""
def readitaloud(result):
documentHTML5='''
Read It Aloud
๐ Read It Aloud
'''
components.html(documentHTML5, width=800, height=300)
#return result
def extract_mime_type(file):
# Check if the input is a string
if isinstance(file, str):
pattern = r"type='(.*?)'"
match = re.search(pattern, file)
if match:
return match.group(1)
else:
raise ValueError(f"Unable to extract MIME type from {file}")
# If it's not a string, assume it's a streamlit.UploadedFile object
elif isinstance(file, streamlit.UploadedFile):
return file.type
else:
raise TypeError("Input should be a string or a streamlit.UploadedFile object")
from io import BytesIO
import re
def extract_file_extension(file):
# get the file name directly from the UploadedFile object
file_name = file.name
pattern = r".*?\.(.*?)$"
match = re.search(pattern, file_name)
if match:
return match.group(1)
else:
raise ValueError(f"Unable to extract file extension from {file_name}")
def pdf2txt(docs):
text = ""
for file in docs:
file_extension = extract_file_extension(file)
# print the file extension
st.write(f"File type extension: {file_extension}")
# read the file according to its extension
try:
if file_extension.lower() in ['py', 'txt', 'html', 'htm', 'xml', 'json']:
text += file.getvalue().decode('utf-8')
elif file_extension.lower() == 'pdf':
from PyPDF2 import PdfReader
pdf = PdfReader(BytesIO(file.getvalue()))
for page in range(len(pdf.pages)):
text += pdf.pages[page].extract_text() # new PyPDF2 syntax
except Exception as e:
st.write(f"Error processing file {file.name}: {e}")
return text
def pdf2txt_old(pdf_docs):
st.write(pdf_docs)
for file in pdf_docs:
mime_type = extract_mime_type(file)
st.write(f"MIME type of file: {mime_type}")
text = ""
for pdf in pdf_docs:
pdf_reader = PdfReader(pdf)
for page in pdf_reader.pages:
text += page.extract_text()
return text
def txt2chunks(text):
text_splitter = CharacterTextSplitter(separator="\n", chunk_size=1000, chunk_overlap=200, length_function=len)
return text_splitter.split_text(text)
def vector_store(text_chunks):
key = os.getenv('OPENAI_API_KEY')
embeddings = OpenAIEmbeddings(openai_api_key=key)
return FAISS.from_texts(texts=text_chunks, embedding=embeddings)
def get_chain(vectorstore):
llm = ChatOpenAI()
memory = ConversationBufferMemory(memory_key='chat_history', return_messages=True)
return ConversationalRetrievalChain.from_llm(llm=llm, retriever=vectorstore.as_retriever(), memory=memory)
def process_user_input(user_question):
response = st.session_state.conversation({'question': user_question})
st.session_state.chat_history = response['chat_history']
for i, message in enumerate(st.session_state.chat_history):
template = user_template if i % 2 == 0 else bot_template
st.write(template.replace("{{MSG}}", message.content), unsafe_allow_html=True)
# Save file output from PDF query results
filename = generate_filename(user_question, 'txt')
#create_file(filename, user_question, message.content)
response = message.content
user_prompt = user_question
create_file(filename, user_prompt, response, should_save)
#st.sidebar.markdown(get_table_download_link(filename), unsafe_allow_html=True)
def divide_prompt(prompt, max_length):
words = prompt.split()
chunks = []
current_chunk = []
current_length = 0
for word in words:
if len(word) + current_length <= max_length:
current_length += len(word) + 1 # Adding 1 to account for spaces
current_chunk.append(word)
else:
chunks.append(' '.join(current_chunk))
current_chunk = [word]
current_length = len(word)
chunks.append(' '.join(current_chunk)) # Append the final chunk
return chunks
def create_zip_of_files(files):
"""
Create a zip file from a list of files.
"""
zip_name = "all_files.zip"
with zipfile.ZipFile(zip_name, 'w') as zipf:
for file in files:
zipf.write(file)
return zip_name
def get_zip_download_link(zip_file):
"""
Generate a link to download the zip file.
"""
with open(zip_file, 'rb') as f:
data = f.read()
b64 = base64.b64encode(data).decode()
href = f'Download All'
return href
def main():
#openai.api_key = os.getenv('OPENAI_API_KEY')
# File type for output, model choice
menu = ["txt", "htm", "xlsx", "csv", "md", "py"]
choice = st.sidebar.selectbox("Output File Type:", menu)
model_choice = st.sidebar.radio("Select Model:", ('gpt-3.5-turbo', 'gpt-3.5-turbo-0301'))
# Audio, transcribe, GPT:
filename = save_and_play_audio(audio_recorder)
if filename is not None:
try:
transcription = transcribe_audio(filename, "whisper-1")
except:
st.write(' ')
st.sidebar.markdown(get_table_download_link(filename), unsafe_allow_html=True)
filename = None
# prompt interfaces
user_prompt = st.text_area("Enter prompts, instructions & questions:", '', height=100)
# file section interface for prompts against large documents as context
collength, colupload = st.columns([2,3]) # adjust the ratio as needed
with collength:
max_length = st.slider("File section length for large files", min_value=1000, max_value=128000, value=12000, step=1000)
with colupload:
uploaded_file = st.file_uploader("Add a file for context:", type=["pdf", "xml", "json", "xlsx", "csv", "html", "htm", "md", "txt"])
# Document section chat
document_sections = deque()
document_responses = {}
if uploaded_file is not None:
file_content = read_file_content(uploaded_file, max_length)
document_sections.extend(divide_document(file_content, max_length))
if len(document_sections) > 0:
if st.button("๐๏ธ View Upload"):
st.markdown("**Sections of the uploaded file:**")
for i, section in enumerate(list(document_sections)):
st.markdown(f"**Section {i+1}**\n{section}")
st.markdown("**Chat with the model:**")
for i, section in enumerate(list(document_sections)):
if i in document_responses:
st.markdown(f"**Section {i+1}**\n{document_responses[i]}")
else:
if st.button(f"Chat about Section {i+1}"):
st.write('Reasoning with your inputs...')
response = chat_with_model(user_prompt, section, model_choice) # *************************************
st.write('Response:')
st.write(response)
document_responses[i] = response
filename = generate_filename(f"{user_prompt}_section_{i+1}", choice)
create_file(filename, user_prompt, response, should_save)
st.sidebar.markdown(get_table_download_link(filename), unsafe_allow_html=True)
if st.button('๐ฌ Chat'):
st.write('Reasoning with your inputs...')
#response = chat_with_model(user_prompt, ''.join(list(document_sections,)), model_choice) # *************************************
# Divide the user_prompt into smaller sections
user_prompt_sections = divide_prompt(user_prompt, max_length)
full_response = ''
for prompt_section in user_prompt_sections:
# Process each section with the model
response = chat_with_model(prompt_section, ''.join(list(document_sections)), model_choice)
full_response += response + '\n' # Combine the responses
#st.write('Response:')
#st.write(full_response)
response = full_response
st.write('Response:')
st.write(response)
filename = generate_filename(user_prompt, choice)
create_file(filename, user_prompt, response, should_save)
st.sidebar.markdown(get_table_download_link(filename), unsafe_allow_html=True)
all_files = glob.glob("*.*")
all_files = [file for file in all_files if len(os.path.splitext(file)[0]) >= 20] # exclude files with short names
all_files.sort(key=lambda x: (os.path.splitext(x)[1], x), reverse=True) # sort by file type and file name in descending order
# Sidebar buttons Download All and Delete All
colDownloadAll, colDeleteAll = st.sidebar.columns([3,3])
with colDownloadAll:
if st.button("โฌ๏ธ Download All"):
zip_file = create_zip_of_files(all_files)
st.markdown(get_zip_download_link(zip_file), unsafe_allow_html=True)
with colDeleteAll:
if st.button("๐ Delete All"):
for file in all_files:
os.remove(file)
st.experimental_rerun()
# Sidebar of Files Saving History and surfacing files as context of prompts and responses
file_contents=''
next_action=''
for file in all_files:
col1, col2, col3, col4, col5 = st.sidebar.columns([1,6,1,1,1]) # adjust the ratio as needed
with col1:
if st.button("๐", key="md_"+file): # md emoji button
with open(file, 'r') as f:
file_contents = f.read()
next_action='md'
with col2:
st.markdown(get_table_download_link(file), unsafe_allow_html=True)
with col3:
if st.button("๐", key="open_"+file): # open emoji button
with open(file, 'r') as f:
file_contents = f.read()
next_action='open'
with col4:
if st.button("๐", key="read_"+file): # search emoji button
with open(file, 'r') as f:
file_contents = f.read()
next_action='search'
with col5:
if st.button("๐", key="delete_"+file):
os.remove(file)
st.experimental_rerun()
if len(file_contents) > 0:
if next_action=='open':
file_content_area = st.text_area("File Contents:", file_contents, height=500)
if next_action=='md':
st.markdown(file_contents)
if next_action=='search':
file_content_area = st.text_area("File Contents:", file_contents, height=500)
st.write('Reasoning with your inputs...')
response = chat_with_model(user_prompt, file_contents, model_choice)
filename = generate_filename(file_contents, choice)
create_file(filename, user_prompt, response, should_save)
st.experimental_rerun()
#st.sidebar.markdown(get_table_download_link(filename), unsafe_allow_html=True)
if __name__ == "__main__":
main()
load_dotenv()
st.write(css, unsafe_allow_html=True)
st.header("Chat with documents :books:")
user_question = st.text_input("Ask a question about your documents:")
if user_question:
process_user_input(user_question)
with st.sidebar:
st.subheader("Your documents")
docs = st.file_uploader("import documents", accept_multiple_files=True)
with st.spinner("Processing"):
raw = pdf2txt(docs)
if len(raw) > 0:
length = str(len(raw))
text_chunks = txt2chunks(raw)
vectorstore = vector_store(text_chunks)
st.session_state.conversation = get_chain(vectorstore)
st.markdown('# AI Search Index of Length:' + length + ' Created.') # add timing
filename = generate_filename(raw, 'txt')
create_file(filename, raw, '', should_save)
#create_file(filename, raw, '')