File size: 10,053 Bytes
2ef6911
4095cfa
1bf2670
2ef6911
3c3225d
3aaeae4
46158ec
3aaeae4
 
 
35a5ffa
 
3aaeae4
 
5915d7a
 
2ef6911
 
 
bef48d1
 
 
999a1fd
 
 
ea0b1ef
 
3176d98
c15629e
 
 
d3bca06
 
b4ffaef
6da8da6
 
 
 
 
 
 
46158ec
56250cf
b4ffaef
 
 
 
 
 
 
46158ec
b4ffaef
 
56250cf
86943bc
 
 
 
 
 
 
 
bc2edb8
46158ec
56250cf
bc2edb8
b31777c
 
bc2edb8
b31777c
 
 
bc2edb8
b31777c
 
 
 
 
 
bc2edb8
b31777c
 
bc2edb8
b31777c
 
 
f72b341
 
b31777c
 
46158ec
 
56250cf
c15629e
 
 
5b7b180
c15629e
 
 
 
 
 
 
 
 
bc2edb8
46158ec
56250cf
bc2edb8
74b3d03
6da8da6
01f7fae
 
 
 
6da8da6
ba804a7
2032029
 
3bb5ed0
 
 
4e9c96c
5b933dd
 
a446da1
 
 
 
74b3d03
 
01f7fae
 
 
 
 
 
 
 
bc2edb8
34ff935
ea00a3f
f7118a9
 
 
 
 
 
 
 
 
66353cd
 
f7118a9
01f7fae
 
 
 
35a5ffa
bc2edb8
ea00a3f
 
34ff935
ea00a3f
6da8da6
 
5b7b180
6da8da6
 
 
ea00a3f
 
34ff935
85eb1e5
 
bc2edb8
35a5ffa
f38b609
34ff935
85eb1e5
 
b4ffaef
c81730f
685e05b
f38b609
c81730f
f38b609
 
56250cf
3aaeae4
 
74b3d03
a446da1
4807660
98aab2d
 
3ff5e5b
56250cf
 
98aab2d
 
46158ec
 
98aab2d
46158ec
 
98aab2d
46158ec
 
 
98aab2d
46158ec
 
 
98aab2d
46158ec
 
74b3d03
98aab2d
 
 
3aaeae4
 
 
 
 
 
 
 
46158ec
 
 
 
 
3aaeae4
f0a6795
6da8da6
f0a6795
 
56250cf
3aaeae4
 
 
 
 
 
 
 
5b7b180
 
 
3aaeae4
5b7b180
3aaeae4
 
5b7b180
3aaeae4
 
 
 
 
 
 
 
 
 
 
56250cf
3aaeae4
 
 
56250cf
3aaeae4
 
 
56250cf
3aaeae4
 
56250cf
3aaeae4
6da8da6
 
3aaeae4
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
##########################################################################
#   app.py   -  Pennwick PDF Chat
#
#   HuggingFace Spaces application to anlayze uploaded PDF files
#           with open-source models ( hkunlp/instructor-xl )
#
#   Mike Pastor  February 17, 2024


import streamlit as st
from streamlit.components.v1 import html

from dotenv import load_dotenv

from PyPDF2 import PdfReader

from PIL import Image

# Local file
from htmlTemplates import css, bot_template, user_template


#  from langchain.embeddings import HuggingFaceInstructEmbeddings
from langchain_community.embeddings import HuggingFaceInstructEmbeddings

# from langchain.vectorstores import FAISS
from langchain_community.vectorstores import FAISS
from langchain.text_splitter import CharacterTextSplitter
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationalRetrievalChain

#  from langchain.llms import HuggingFaceHub
from langchain_community.llms import HuggingFaceHub

##################################################################################
#  Admin flags
DISPLAY_DIALOG_LINES=6

SESSION_STARTED = False


##################################################################################
def extract_pdf_text(pdf_docs):
    text = ""
    for pdf in pdf_docs:
        pdf_reader = PdfReader(pdf)
        for page in pdf_reader.pages:
            text += page.extract_text()
    return text

##################################################################################
#  Chunk size and overlap must not exceed the models capacity!
#
def extract_bitesize_pieces(text):
    text_splitter = CharacterTextSplitter(
        separator="\n",
        chunk_size=800,    #  1000
        chunk_overlap=200,
        length_function=len
    )
    chunks = text_splitter.split_text(text)
    return chunks

##################################################################################
def prepare_embedding_vectors(text_chunks):

    st.write('Here in vector store....', unsafe_allow_html=True)
    # embeddings = OpenAIEmbeddings()

    #  pip install InstructorEmbedding
    #  pip install sentence-transformers==2.2.2
    embeddings = HuggingFaceInstructEmbeddings(model_name="hkunlp/instructor-xl")

    st.write('Here in vector store - got embeddings ', unsafe_allow_html=True)
    #  from InstructorEmbedding import INSTRUCTOR
    # model = INSTRUCTOR('hkunlp/instructor-xl')
    # sentence = "3D ActionSLAM: wearable person tracking in multi-floor environments"
    # instruction = "Represent the Science title:"
    # embeddings = model.encode([[instruction, sentence]])

    # embeddings = model.encode(text_chunks)
    print('have Embeddings:   ')

    # text_chunks="this is a test"
    #   FAISS,  Chroma and other vector databases
    #
    vectorstore = FAISS.from_texts(texts=text_chunks, embedding=embeddings)
    st.write('FAISS succeeds:   ')

    return vectorstore
    
##################################################################################
def prepare_conversation(vectorstore):
    # llm = ChatOpenAI()
    #  llm = HuggingFaceHub(repo_id="google/flan-t5-xxl", model_kwargs={"temperature":0.5, "max_length":512})
    #  google/bigbird-roberta-base     facebook/bart-large
    llm = HuggingFaceHub(repo_id="google/flan-t5-xxl", model_kwargs={"temperature": 0.7, "max_length": 512})

    memory = ConversationBufferMemory(
        memory_key='chat_history', return_messages=True)
    conversation_chain = ConversationalRetrievalChain.from_llm(
        llm=llm,
        retriever=vectorstore.as_retriever(),
        memory=memory,
    )
    return conversation_chain

##################################################################################
def process_user_question(user_question):

    print('process_user_question called: \n')

    # if not SESSION_STARTED:
    #     print('No Session')
    #     st.write( 'Please upload and analyze your PDF files first!')
    #     return
        
    if user_question == None :
        print('question is null')
        return
    if user_question == '' :
        print('question is blank')
        return
    if st == None :
        print('session is null')
        return
    if st.session_state == None :
        print('session STATE is null')
        return

    print('question is: ', user_question)
    print('\nsession is: ', st )

    # try:
    #     response = st.session_state.conversation({'question': user_question})
    #     # response = st.session_state.conversation({'summarization': user_question})
    #     st.session_state.chat_history = response['chat_history']
    # Exception:
    #     st.write( 'Please upload and analyze your PDF files first!')
    #     return

    # st.empty()

    # try:
    #     st.session_state.conversation({'question': "Summarize the document"})
    #     # if "key" not in st.session_state:
    #     #     st.write('Good')
    # except:
    #     st.error("Please upload and analyze your PDF files first!")
    #     return

    if st.session_state.conversation == None:
        st.error("Please upload and analyze your PDF files first!")
        return
            
    response = st.session_state.conversation({'question': user_question})
    st.session_state.chat_history = response['chat_history']
    results_size = len(response['chat_history'])
    
    results_string  = ""

    print('results_size is: ', results_size )

    for i, message in enumerate(st.session_state.chat_history):

        #  Scrolling does not display the last printed line, 
        #    so only print the last 6 lines
        #
        print('results_size on msg: ', results_size, i, ( results_size - DISPLAY_DIALOG_LINES ) )
        if results_size > DISPLAY_DIALOG_LINES:
            if i < ( results_size - DISPLAY_DIALOG_LINES ):
                continue
                
        if i % 2 == 0:
            # st.write(user_template.replace(
            #     "{{MSG}}", message.content), unsafe_allow_html=True)

            results_string += ( "<p>" + message.content + "</p>" )

        else:
            # st.write(bot_template.replace(
            #     "{{MSG}}", message.content), unsafe_allow_html=True)

            results_string += ( "<p>" + "-- " + message.content + "</p>" )


    html(results_string, height=300, scrolling=True)
    
    
###################################################################################
def main():

    print( 'Pennwick Starting up...\n')
    # Load the environment variables - if any
    load_dotenv()

    ##################################################################################
    #  st.set_page_config(page_title="Pennwick PDF Analyzer", page_icon=":books:")
    # im = Image.open("robot_icon.ico")
    # st.set_page_config(page_title="Pennwick PDF Analyzer", page_icon=im )
    # st.set_page_config(page_title="Pennwick PDF Analyzer")

    # import base64
    # from PIL import Image
    
    # # Open your image
    # image = Image.open("robot_icon.ico")
    
    # # Convert image to base64 string
    # with open("robot_icon.ico", "rb") as f:
    #     encoded_string = base64.b64encode(f.read()).decode()
    
    # # Set page config with base64 string
    # st.set_page_config(page_title="Pennwick File Analyzer 2", page_icon=f"data:image/ico;base64,{encoded_string}")


    st.set_page_config(page_title="Pennwick File Analyzer", page_icon="./robot_icon.ico")
    
    print( 'prepared page...\n')


    ###################

    st.write(css, unsafe_allow_html=True)

    if "conversation" not in st.session_state:
        st.session_state.conversation = None
    if "chat_history" not in st.session_state:
        st.session_state.chat_history = None

    # st.header("Pennwick File Analyzer :shark:")
    # st.header("Pennwick File Analyzer 2")
        
    st.image("robot_icon.png", width=96 )
    st.header(f"Pennwick File Analyzer")

    user_question = None
    user_question = st.text_input("Ask the  Open Source - Flan-T5 Model  a question about your uploaded documents:")
    if user_question != None:
        print( 'calling process question', user_question)
        process_user_question(user_question)

    # st.write( user_template, unsafe_allow_html=True)
    # st.write(user_template.replace( "{{MSG}}", "Hello robot!"), unsafe_allow_html=True)
    # st.write(bot_template.replace( "{{MSG}}", "Hello human!"), unsafe_allow_html=True)


    with st.sidebar:

        st.subheader("Which documents would you like to analyze?")
        st.subheader("(no data is saved beyond the session)")
        
        pdf_docs = st.file_uploader(
            "Upload your PDF documents here and click on 'Analyze'", accept_multiple_files=True)

        # Upon button press
        if st.button("Analyze these files"):
            with st.spinner("Processing..."):

                #################################################################
                #  Track the overall time for file processing into Vectors
                # #
                from datetime import datetime
                global_now = datetime.now()
                global_current_time = global_now.strftime("%H:%M:%S")
                st.write("Vectorizing Files - Current Time =", global_current_time)

                # get pdf text
                raw_text = extract_pdf_text(pdf_docs)
                #  st.write(raw_text)

                # # get the text chunks
                text_chunks = extract_bitesize_pieces(raw_text)
                # st.write(text_chunks)

                # # create vector store
                vectorstore = prepare_embedding_vectors(text_chunks)

                # # create conversation chain
                st.session_state.conversation = prepare_conversation(vectorstore)

                SESSION_STARTED = True
                
                # Mission Complete!
                global_later = datetime.now()
                st.write("Files Vectorized - Total EXECUTION Time =",
                         (global_later - global_now), global_later)


if __name__ == '__main__':
    main()