Upload chatbot_app_poc.py

chatbot_app_poc.py

@@ -0,0 +1,380 @@
+import streamlit as st
+import datetime
+import numpy as np
+import gspread
+from google.oauth2 import service_account
+
+# Add this function to create a Google Sheets service
+def create_google_sheets_service(json_credentials_path, scopes):
+    creds = service_account.Credentials.from_service_account_file(json_credentials_path).with_scopes(scopes)
+    return gspread.authorize(creds)
+
+        
+from datetime import datetime
+import pytz
+import requests
+
+def get_user_ip():
+    try:
+        response = requests.get("https://api.ipify.org?format=json")
+        ip = response.json()['ip']
+    except:
+        ip = "Unknown"
+    return ip
+
+
+from google.api_core.retry import Retry
+from google.api_core import retry
+
+
+def write_data_to_google_sheet(service, spreadsheet_url, sheet_name, data):
+    sheet = service.open_by_url(spreadsheet_url).worksheet(sheet_name)
+
+    # Add header row
+    header_row = ["Questions", "Answers", "Timestamp", "User IP"]
+    for i, header in enumerate(header_row, start=1):
+        sheet.update_cell(1, i, header)
+
+    # Set timezone to Saudi Arabia time
+    saudi_timezone = pytz.timezone("Asia/Riyadh")
+
+    # Get user's IP address
+    user_ip = get_user_ip()
+
+    # Find the next empty row
+    next_row = len(sheet.get_all_values()) + 1
+
+    # Write data to the Google Sheet
+    for i, item in enumerate(data, start=next_row):
+        sheet.update_cell(i, 1, item['query'])
+        sheet.update_cell(i, 2, item['response'])
+        saudi_time = datetime.now(saudi_timezone).strftime("%Y-%m-%d %H:%M:%S")
+        sheet.update_cell(i, 3, saudi_time)
+        sheet.update_cell(i, 4, user_ip)
+
+
+
+
+
+
+
+# Add these lines to the beginning of your `app` function
+json_credentials_path = 'credentials.json'  # Replace with the path to your JSON credentials file
+scopes = ['https://www.googleapis.com/auth/spreadsheets']
+
+service = create_google_sheets_service(json_credentials_path, scopes)
+spreadsheet_url = 'https://docs.google.com/spreadsheets/d/1R1AUf0Bzk5fLTpV6vk023DW7FV19kBT3e1lPWysDW2Q/edit#gid=1555077198'
+sheet_name = 'Sheet1'  # Replace with the name of the sheet where you want to store the data
+        
+
+
+
+
+#@title State of Union Text
+#state_of_the_union = """ txt_file"""
+
+# Environment Vars
+#os.environ["OPENAI_API_KEY"] = openai_api_key
+import os
+os.environ["OPENAI_API_KEY"] = openai_api_key
+os.environ['OPENAI_API_KEY'] = st.secrets['OPENAI_API_KEY']
+
+
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.document_loaders.csv_loader import CSVLoader
+from langchain.vectorstores.faiss import FAISS
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.text_splitter import CharacterTextSplitter
+from langchain import OpenAI, VectorDBQA
+from langdetect import detect
+from googletrans import Translator
+from langchain.vectorstores import Chroma
+from langchain.document_loaders import PyPDFLoader
+from langchain.chains import RetrievalQA
+from langchain.llms import OpenAI
+from langchain.document_loaders import TextLoader
+#from langchain.translator import OpenAITranslator
+import openai
+from datetime import datetime
+import pandas as pd
+import pytz
+
+
+import streamlit as st
+from hashlib import sha256
+
+def create_hashed_password(password):
+    return sha256(password.encode('utf-8')).hexdigest()
+
+def login():
+    st.title('Please Login')
+
+    entered_username = st.text_input('Username')
+    entered_password = st.text_input('Password', type='password')
+
+    if st.button('Login'):
+        names = ['User', 'Customer']
+        usernames = ['warba', 'Warba']
+        passwords = ['warba123', 'warba123']
+
+        hashed_passwords = [create_hashed_password(password) for password in passwords]
+
+        for name, username, hashed_password in zip(names, usernames, hashed_passwords):
+            if username == entered_username and hashed_password == create_hashed_password(entered_password):
+                st.session_state["authentication_status"] = True
+                st.session_state["name"] = name
+                break
+        else:
+            st.session_state["authentication_status"] = False
+
+        if st.session_state.get("authentication_status", None):
+            return True
+        elif st.session_state["authentication_status"] == False:
+            st.error('Sorry, wrong login credentials')
+            return False
+        elif st.session_state["authentication_status"] == None:
+            st.warning('Please enter your username and password')
+            return False
+    else:
+        return False
+
+
+
+#text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+#texts = text_splitter.split_text(state_of_the_union)
+#loader = PyPDFLoader("warba_5_6.pdf")
+#documents = loader.load()
+#texts = text_splitter.split_documents(documents)
+
+#################
+from langchain.chat_models import ChatOpenAI
+from langchain.chains import ConversationalRetrievalChain
+from langchain.prompts.prompt import PromptTemplate
+from langchain.callbacks import get_openai_callback
+qa_template = """
+        You are a helpful AI assistant named Q&A bot developed and created by Warba Bank Developers. The user gives you a file its content is represented by the following pieces of context, use them to answer the question at the end.
+        If you don't know the answer, just say you don't know. Do NOT try to make up an answer.
+        If the question is not related to the context, politely respond that you are tuned to only answer questions that are related to the context.
+        Use as much detail as possible when responding.
+
+        context: {context}
+        =========
+        question: {question}
+        ======
+        """
+QA_PROMPT = PromptTemplate(template=qa_template, input_variables=["context","question" ])
+
+#loader = CSVLoader("Warba_QA_bot_full_dataset_June_14_csv.csv", csv_args = {"delimiter": ','})
+#documents = loader.load()
+loader = CSVLoader(file_path="Warba_QA_bot_full_dataset_June_14_csv_updated.csv", encoding="utf-8",csv_args={'delimiter': ',',})
+data = loader.load()
+#text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+text_splitter = RecursiveCharacterTextSplitter(chunk_size = 1000,chunk_overlap  = 0,length_function = len,)
+embeddings = OpenAIEmbeddings()
+vectors = FAISS.from_documents(data, embeddings)
+chain = ConversationalRetrievalChain.from_llm(llm = ChatOpenAI(temperature=0.0,model_name='gpt-3.5-turbo', openai_api_key=st.secrets['OPENAI_API_KEY']),
+retriever=vectors.as_retriever(),max_tokens_limit=4097,combine_docs_chain_kwargs={"prompt": QA_PROMPT})
+#faissIndex = FAISS.from_documents(docs, OpenAIEmbeddings())
+#faissIndex.save_local("faiss_warba_docs")
+#from langchain.chains import RetrievalQA
+#from langchain.chat_models import ChatOpenAI
+#chatbot = RetrievalQA.from_chain_type(llm=ChatOpenAI(openai_api_key=st.secrets['OPENAI_API_KEY'],temperature=0, model_name="gpt-3.5-turbo", max_tokens=256), chain_type="stuff", retriever=FAISS.load_local("faiss_warba_docs", OpenAIEmbeddings()).as_retriever(search_type="similarity", search_kwargs={"k":1}))
+
+
+###embeddings = OpenAIEmbeddings()
+###text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+###texts = text_splitter.split_text(state_of_the_union)
+###vectorstore = FAISS.from_texts(texts, embeddings)
+
+#import numpy as np
+
+#text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+#texts = text_splitter.split_text(state_of_the_union)
+
+#embeddings = OpenAIEmbeddings()
+#vectorstore = FAISS.from_texts(texts, embeddings)
+
+
+#db = Chroma.from_documents(texts, embeddings)
+#retriever = db.as_retriever(search_type="similarity", search_kwargs={"k":2})
+#llm = OpenAI(model_name='gpt-3.5-turbo',temperature=0, max_tokens=256 )
+#qa = VectorDBQA.from_chain_type(llm, chain_type="stuff", vectorstore=vectorstore)
+from langchain.chat_models import ChatOpenAI
+#qa = VectorDBQA.from_chain_type(llm=OpenAI(model_name='gpt-3.5-turbo',temperature=0.2,max_tokens=256), chain_type="stuff", vectorstore=vectorstore)
+#qa = VectorDBQA.from_chain_type(llm=ChatOpenAI(model_name='gpt-3.5-turbo',temperature=0.2,max_tokens=256), chain_type="stuff", vectorstore=vectorstore)
+#qa = RetrievalQA.from_chain_type(llm=OpenAI(model_name='gpt-3.5-turbo'), chain_type="stuff", retriever=retriever, return_source_documents=True)
+from langchain.chains import load_chain
+
+#translator = OpenAITranslator()
+from googletrans import Translator
+
+#chain = load_chain("lc://chains/vector-db-qa/stuff/chain.json", vectorstore=vectorstore)
+#from langchain.chains.question_answering import load_qa_chain
+#chain = load_qa_chain(llm=OpenAI(model_name='gpt-3.5-turbo'), chain_type="stuff")
+
+
+from googletrans import Translator
+
+def translate_to_arabic(text):
+    translator = Translator()
+    result = translator.translate(text, dest='ar')
+    return result.text
+
+
+
+translator = Translator()
+
+
+from langdetect import detect
+
+
+import time
+import streamlit as st
+from datetime import datetime
+import pytz
+
+#def run_chain(query):
+    #return chain.run(query)
+
+def run_chain(chat_history, question):
+    return chain.run({'chat_history': chat_history, 'question': question})
+
+
+def clear_conversation():
+    if (
+        st.button("🧹 Clear conversation", use_container_width=True)
+        or "history" not in st.session_state
+    ):
+        st.session_state.history = []
+
+def download_conversation():
+    conversation_df = pd.DataFrame(
+        st.session_state.history, columns=["timestamp", "query", "response"]
+    )
+    csv = conversation_df.to_csv(index=False)
+
+    st.download_button(
+        label="💾 Download conversation",
+        data=csv,
+        file_name=f"conversation_{datetime.now().strftime('%Y%m%d%H%M')}.csv",
+        mime="text/csv",
+        use_container_width=True,
+    )
+
+def app():
+    st.set_page_config(page_title="Q&A Bot", page_icon=":guardsman:")
+
+    st.markdown("""
+        <style>
+            body {
+                background-color: #f0f2f6;
+            }
+            .title {
+                font-size: 25px;
+                font-weight: bold;
+                color: #151f6d;
+                text-align: center;
+            }
+            .response-block {
+                background-color: #151f6d;
+                padding: 10px;
+                color: white;
+                border-radius: 5px;
+                margin-top: 10px;
+                text-align: center;
+                font-size: 16px;  # Increase font size by one degree
+            }
+            .stTextInput>div>div>input {
+                background-color: white;
+            }
+            .stButton>button {
+                width: 100%;
+                color: white;
+                background-color: #151f6d;
+            }
+        </style>
+    """, unsafe_allow_html=True)
+
+    st.markdown('<div class="title">Questions and Answers Bot for Warba Bank.</div>', unsafe_allow_html=True)
+
+    st.write("")  # Empty line for spacing
+    st.write("")  # Empty line for spacing
+
+    sidebar = st.sidebar
+    show_history = sidebar.checkbox("Show conversation history", value=False)
+    
+    # Add the checkbox for multi-line input in the sidebar
+    multiline = sidebar.checkbox('Use multi-line input')
+
+    with sidebar.expander("More options"):
+        clear_conversation()
+        download_conversation()
+
+    col1, col2 = st.columns([3,1])
+    with col1:
+        # Depending on the state of the checkbox, display a single-line input or a multi-line input
+        if multiline:
+            query = st.text_area("Enter a question and get an answer from Q&A Bot:")
+        else:
+            query = st.text_input("Enter a question and get an answer from Q&A Bot:")
+
+    thinking_message_text = col1.empty()  # Create a placeholder for the 'Thinking...' text
+    thinking_message_bar = col1.empty()  # Create a placeholder for the progress bar
+
+    response_block = col1.empty()  # Create a placeholder for the response block
+
+    with col2:
+        st.write("")  # Empty line for spacing
+        st.write("")  # Empty line for spacing
+        if st.button("Ask"):
+            if query:
+                # Start progress bar
+                progress_bar = thinking_message_bar.progress(0)
+                for i in range(100):
+                    # Update the progress bar with each iteration.
+                    time.sleep(0.01)  # add delay for demonstration
+                    progress_bar.progress(i + 1)
+                    thinking_message_text.markdown(f'Thinking... {i+1}%', unsafe_allow_html=True)
+                
+                sa_time = datetime.now(pytz.timezone('Asia/Riyadh'))
+                timestamp = sa_time.strftime('%Y-%m-%d %H:%M:%S')
+                #response = run_chain(query)
+                response = run_chain("", query)
+
+
+                # Clear the progress bar and the 'Thinking...' text
+                thinking_message_bar.empty()
+                thinking_message_text.empty()
+
+                # Display the response
+                response_block.markdown(f'<div class="response-block"> Answer: {response}</div>', unsafe_allow_html=True)
+                conversation_item = {
+                    'timestamp': timestamp,
+                    'query': query,
+                    'response': response
+                }
+                st.session_state.history.append(conversation_item)
+
+
+                # Write data to Google Sheet
+                write_data_to_google_sheet(service, spreadsheet_url, sheet_name, [conversation_item])
+
+    # Only show conversation history if checkbox is checked
+    if show_history:
+        st.write('\n\n## Conversation history')
+        for item in reversed(st.session_state.history):
+            st.write(f'### Question: {item["query"]}')
+            st.write(f'### Answer: {item["response"]}')
+            st.write('---')
+
+            
+if __name__ == "__main__":
+    #st.set_page_config(page_title="My Streamlit App")
+    if 'authentication_status' not in st.session_state or st.session_state["authentication_status"] == False:
+        login_successful = login()
+        if login_successful:
+            st.experimental_rerun()
+    else:
+        app()
+
+