Update backupapp.py

backupapp.py

@@ -1,209 +1,442 @@
-import gradio as gr
-import os 
-import json 
+import streamlit as st
+import openai
+import os
+import base64
+import glob
+import json
+import mistune
+import pytz
+import math
 import requests
+import time
+import re
+import textract
 
-#Streaming endpoint 
-API_URL = "https://api.openai.com/v1/chat/completions" #os.getenv("API_URL") + "/generate_stream"
-OPENAI_API_KEY= os.environ["HF_TOKEN"] # Add a token to this space .  Then copy it to the repository secret in this spaces settings panel.  os.environ reads from there.
-# Keys for Open AI ChatGPT API usage are created from here: https://platform.openai.com/account/api-keys
-
-def predict(inputs, top_p, temperature, chat_counter, chatbot=[], history=[]):  #repetition_penalty, top_k
-
-    # 1. Set up a payload
-    payload = {
-    "model": "gpt-3.5-turbo",
-    "messages": [{"role": "user", "content": f"{inputs}"}],
-    "temperature" : 1.0,
-    "top_p":1.0,
-    "n" : 1,
-    "stream": True,
-    "presence_penalty":0,
-    "frequency_penalty":0,
-    }
+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
+
+
+
+def generate_filename(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
 
-    # 2. Define your headers and add a key from https://platform.openai.com/account/api-keys
+
+def transcribe_audio(openai_key, file_path, model):
+    OPENAI_API_URL = "https://api.openai.com/v1/audio/transcriptions"
     headers = {
-    "Content-Type": "application/json",
-    "Authorization": f"Bearer {OPENAI_API_KEY}"
+        "Authorization": f"Bearer {openai_key}",
     }
+    with open(file_path, 'rb') as f:
+        data = {'file': f}
+        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)
+        return transcript
+    else:
+        st.write(response.json())
+        st.error("Error in API call.")
+        return None
 
-    # 3. Create a chat counter loop that feeds [Predict next best anything based on last input and attention with memory defined by introspective attention over time]
-    print(f"chat_counter - {chat_counter}")
-    if chat_counter != 0 :
-        messages=[]
-        for data in chatbot:
-          temp1 = {}
-          temp1["role"] = "user" 
-          temp1["content"] = data[0] 
-          temp2 = {}
-          temp2["role"] = "assistant" 
-          temp2["content"] = data[1]
-          messages.append(temp1)
-          messages.append(temp2)
-        temp3 = {}
-        temp3["role"] = "user" 
-        temp3["content"] = inputs
-        messages.append(temp3)
-        payload = {
-        "model": "gpt-3.5-turbo",
-        "messages": messages, #[{"role": "user", "content": f"{inputs}"}],
-        "temperature" : temperature, #1.0,
-        "top_p": top_p, #1.0,
-        "n" : 1,
-        "stream": True,
-        "presence_penalty":0,
-        "frequency_penalty":0,
-        }
-    chat_counter+=1
-
-    # 4. POST it to OPENAI API
-    history.append(inputs)
-    print(f"payload is - {payload}")
-    response = requests.post(API_URL, headers=headers, json=payload, stream=True)
-    token_counter = 0 
-    partial_words = "" 
-
-    # 5. Iterate through response lines and structure readable response
-    counter=0
-    for chunk in response.iter_lines():
-        if counter == 0:
-          counter+=1
-          continue
-        if chunk.decode() :
-          chunk = chunk.decode()
-          if len(chunk) > 12 and "content" in json.loads(chunk[6:])['choices'][0]['delta']:
-              partial_words = partial_words + json.loads(chunk[6:])['choices'][0]["delta"]["content"]
-              if token_counter == 0:
-                history.append(" " + partial_words)
-              else:
-                history[-1] = partial_words
-              chat = [(history[i], history[i + 1]) for i in range(0, len(history) - 1, 2) ]  # convert to tuples of list
-              token_counter+=1
-              yield chat, history, chat_counter 
-                   
-
-def reset_textbox():
-    return gr.update(value='')
+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
 
+def create_file(filename, prompt, response):
+    if filename.endswith(".txt"):
+        with open(filename, 'w') as file:
+            file.write(f"{prompt}\n{response}")
+    elif filename.endswith(".htm"):
+        with open(filename, 'w') as file:
+            file.write(f"{prompt}   {response}")
+    elif filename.endswith(".md"):
+        with open(filename, 'w') as file:
+            file.write(f"{prompt}\n\n{response}")
+            
+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'<a href="data:{mime_type};base64,{b64}" target="_blank" download="{file_name}">{file_name}</a>'
+    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 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 = []
+
+    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)
+    return full_reply_content
 
-# Episodic and Semantic IO
-def list_files(file_path):
-    import os
-    icon_csv = "📄 "
-    icon_txt = "📑 "
-    current_directory = os.getcwd()
-    file_list = []
-    for filename in os.listdir(current_directory):
-        if filename.endswith(".csv"):
-            file_list.append(icon_csv + filename)
-        elif filename.endswith(".txt"):
-            file_list.append(icon_txt + filename)
-    if file_list:
-        return "\n".join(file_list)
+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 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:
-        return "No .csv or .txt files found in the current directory."
-
-# Function to read a file
-def read_file(file_path):
-    try:
-        with open(file_path, "r") as file:
-            contents = file.read()
-            return f"{contents}"
-            #return f"Contents of {file_path}:\n{contents}"
-    except FileNotFoundError:
-        return "File not found."
-
-# Function to delete a file
-def delete_file(file_path):
-    try:
-        import os
-        os.remove(file_path)
-        return f"{file_path} has been deleted."
-    except FileNotFoundError:
-        return "File not found."
-
-# Function to write to a file
-def write_file(file_path, content):
-    try:
-        with open(file_path, "w") as file:
-            file.write(content)
-        return f"Successfully written to {file_path}."
-    except:
-        return "Error occurred while writing to file."
-
-# Function to append to a file
-def append_file(file_path, content):
-    try:
-        with open(file_path, "a") as file:
-            file.write(content)
-        return f"Successfully appended to {file_path}."
-    except:
-        return "Error occurred while appending to file."
-
-
-title = """<h1 align="center">Memory Chat Story Generator ChatGPT</h1>"""
-description = """
-## ChatGPT Datasets 📚
-- WebText
-- Common Crawl
-- BooksCorpus
-- English Wikipedia
-- Toronto Books Corpus
-- OpenWebText
-## ChatGPT Datasets - Details 📚
-- **WebText:** A dataset of web pages crawled from domains on the Alexa top 5,000 list. This dataset was used to pretrain GPT-2.
-  - [WebText: A Large-Scale Unsupervised Text Corpus by Radford et al.](https://paperswithcode.com/dataset/webtext)
-- **Common Crawl:** A dataset of web pages from a variety of domains, which is updated regularly. This dataset was used to pretrain GPT-3.
-  - [Language Models are Few-Shot Learners](https://paperswithcode.com/dataset/common-crawl) by Brown et al.
-- **BooksCorpus:** A dataset of over 11,000 books from a variety of genres.
-  - [Scalable Methods for 8 Billion Token Language Modeling](https://paperswithcode.com/dataset/bookcorpus) by Zhu et al.
-- **English Wikipedia:** A dump of the English-language Wikipedia as of 2018, with articles from 2001-2017.
-  - [Improving Language Understanding by Generative Pre-Training](https://huggingface.co/spaces/awacke1/WikipediaUltimateAISearch?logs=build) Space for Wikipedia Search
-- **Toronto Books Corpus:** A dataset of over 7,000 books from a variety of genres, collected by the University of Toronto.
-  - [Massively Multilingual Sentence Embeddings for Zero-Shot Cross-Lingual Transfer and Beyond](https://paperswithcode.com/dataset/bookcorpus) by Schwenk and Douze.
-- **OpenWebText:** A dataset of web pages that were filtered to remove content that was likely to be low-quality or spammy. This dataset was used to pretrain GPT-3.
-  - [Language Models are Few-Shot Learners](https://paperswithcode.com/dataset/openwebtext) by Brown et al.  
-  """
-
-# 6. Use Gradio to pull it all together
-with gr.Blocks(css = """#col_container {width: 1400px; margin-left: auto; margin-right: auto;} #chatbot {height: 600px; overflow: auto;}""") as demo:
-    gr.HTML(title)
-    with gr.Column(elem_id = "col_container"):
-        inputs = gr.Textbox(placeholder= "Hi there!", label= "Type an input and press Enter")
-        chatbot = gr.Chatbot(elem_id='chatbot')
-        state = gr.State([])
-        b1 = gr.Button()
-        with gr.Accordion("Parameters", open=False):
-            top_p = gr.Slider( minimum=-0, maximum=1.0, value=1.0, step=0.05, interactive=True, label="Top-p (nucleus sampling)",)
-            temperature = gr.Slider( minimum=-0, maximum=5.0, value=1.0, step=0.1, interactive=True, label="Temperature",)
-            chat_counter = gr.Number(value=0, visible=True, precision=0)
+        raise TypeError("Input should be a string or a streamlit.UploadedFile object")
 
-            
-    # Episodic/Semantic IO
-    fileName = gr.Textbox(label="Filename")
-    fileContent = gr.TextArea(label="File Content")
-    completedMessage = gr.Textbox(label="Completed")
-    label = gr.Label()
-    with gr.Row():
-        listFiles = gr.Button("📄 List File(s)")
-        readFile = gr.Button("📖 Read File")
-        saveFile = gr.Button("💾 Save File")
-        deleteFile = gr.Button("🗑️ Delete File")
-        appendFile = gr.Button("➕ Append File")
-    listFiles.click(list_files, inputs=fileName, outputs=fileContent)
-    readFile.click(read_file, inputs=fileName, outputs=fileContent)
-    saveFile.click(write_file, inputs=[fileName, fileContent], outputs=completedMessage)
-    deleteFile.click(delete_file, inputs=fileName, outputs=completedMessage)
-    appendFile.click(append_file, inputs=[fileName, fileContent], outputs=completedMessage )
+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}")
     
-    inputs.submit(predict, [inputs, top_p, temperature,chat_counter, chatbot, state], [chatbot, state, chat_counter])
-    b1.click(predict, [inputs, top_p, temperature, chat_counter, chatbot, state], [chatbot, state, chat_counter])
-    b1.click(reset_textbox, [], [inputs])
-    inputs.submit(reset_textbox, [], [inputs])
-    gr.Markdown(description)
+    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)
+        
+        #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
     
-    demo.queue().launch(debug=True)
+def main():
+    # Sidebar and global
+    openai.api_key = os.getenv('OPENAI_API_KEY')
+    st.set_page_config(page_title="GPT Streamlit Document Reasoner",layout="wide")
+
+    # File type for output, model choice
+    menu = ["txt", "htm", "xlsx", "csv", "md", "py"]  #619
+    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:
+        transcription = transcribe_audio(openai.api_key, filename, "whisper-1")
+        st.sidebar.markdown(get_table_download_link(filename), unsafe_allow_html=True)
+        filename=None # since transcription is finished next time just use the saved transcript
+
+    # 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)
+                    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)
+        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 of files
+    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, file_contents, response)
+
+            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, '')