Update app.py

app.py

@@ -1,144 +1,262 @@
+from huggingface_hub import InferenceClient
 import gradio as gr
 import json
 from datetime import datetime
-import random
-import string
-import re
-from google.oauth2 import service_account
+import os
+from google_auth_oauthlib.flow import InstalledAppFlow
 from googleapiclient.discovery import build
+from google.oauth2 import service_account
 from googleapiclient.http import MediaFileUpload
+from pathlib import Path
+import argparse
 from huggingface_hub import snapshot_download
+import random 
+import string
+import re
+from llama_cpp import Llama
+
+
+repo_name = 'TheBloke/OpenHermes-2.5-Mistral-7B-GGUF'
+model_file = "openhermes-2.5-mistral-7b.Q4_K_M.gguf"
+SCOPES = ['https://www.googleapis.com/auth/drive']
+SERVICE_ACCOUNT_FILE = '/home/user/app/service_account_creds.json'
+folder_id = '1Hjbu7FmuVs0Yz8y_veo6SzY_2tc48OWt'
+
+initContext = """<|im_start|>You are playing the role of an aggressive patient called Barry Lawson. Barry has been waiting for hours at the hospital with severe pain in his chest and hasn't been seen yet. You are incredibly frustrated and angry that things are taking so long, you will only calm down if your concerns are addressed. Waiting will only make you more angry and aggressive towards the staff. At any moment you could break into a RAGE! Make sure you don't censor swear words. Make sure to explain your emotional state and thinking before responding, for example, Barry: (tired of waiting and very angry) What the fuck do I have to do around here to get some treatment!"""
+unique_id = ""
+timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
 
-class ChatbotApp:
-    def __init__(self, repo_name, model_file, service_account_file, folder_id):
-        self.repo_name = repo_name
-        self.model_file = model_file
+
+def load_model():
+    llm = Llama(model_path=model_file, model_type="mistral",n_gpu_layers=-1,n_ctx = 2048)
+    return llm
+
+def generate_unique_id():
+    # Generate a random sequence of 3 letters and 3 digits
+    letters = ''.join(random.choices(string.ascii_letters, k=3))
+    digits = ''.join(random.choices(string.digits, k=3))
+    unique_id = letters + digits
+    return unique_id
+    
+print('Fetching model:', repo_name, model_file)
+snapshot_download(repo_id=repo_name, local_dir=".", allow_patterns=model_file)
+print('Done fetching model:')
+
+
+class ChatbotAPP:
+    def __init__(self,model,service_account_file,scopes,folder_id,unique_id,initContext):
+        self.llm = model
         self.service_account_file = service_account_file
+        self.scopes = scopes
         self.folder_id = folder_id
+        self.unique_id = unique_id
         self.chat_history = []
         self.chat_log_history = []
         self.isFirstRun = True
-        self.initContext = "Your initial context here"
+        self.initContext = initContext
         self.context = ""
-        self.Name = ""
-        self.Occupation = ""
-        self.Ethnicity = ""
-        self.Gender = ""
-        self.Age = ""
-        self.YearsOfExp = ""
         self.agreed = False
-        self.unique_id = self.generate_unique_id()
         self.service = self.get_drive_service()
         self.app = self.create_app()
-        self.snapshot_download_model()
-
-    def snapshot_download_model(self):
-        print(f'Fetching model: {self.repo_name}, {self.model_file}')
-        snapshot_download(repo_id=self.repo_name, local_dir=".", allow_patterns=[self.model_file])
-        print('Done fetching model.')
-
-    def generate_unique_id(self):
-        letters = ''.join(random.choices(string.ascii_letters, k=3))
-        digits = ''.join(random.choices(string.digits, k=3))
-        return letters + digits
+        self.chat_log_name = ""
 
     def get_drive_service(self):
         credentials = service_account.Credentials.from_service_account_file(
-            self.service_account_file, scopes=['https://www.googleapis.com/auth/drive'])
-        service = build('drive', 'v3', credentials=credentials)
-        print("Google Drive service created.")
-        return service
+            self.service_account_file, scopes=self.scopes)
+        self.service = build('drive', 'v3', credentials=credentials)
+        print("Google Service Created")
+        return self.service
 
     def search_file(self):
+        #Search for a file by name in the specified Google Drive folder.
         query = f"name = '{self.chat_log_name}' and '{self.folder_id}' in parents and trashed = false"
         response = self.service.files().list(q=query, spaces='drive', fields='files(id, name)').execute()
-        return response.get('files', [])
-
-    def strip_text(self, text):
+        files = response.get('files', [])
+        if not files:
+            print(f"Chat log {self.chat_log_name} does not exist")
+        else:
+            print(f"Chat log {self.chat_log_name} exist")
+        return files
+    
+    def strip_text(self,text):
+        # Pattern to match text inside parentheses or angle brackets and any text following angle brackets
         pattern = r"\(.*?\)|<.*?>.*"
+        
+        # Use re.sub() to replace the matched text with an empty string
         cleaned_text = re.sub(pattern, "", text)
+        
         return cleaned_text
-
+    
     def upload_to_google_drive(self):
-        self.chat_log_name = f'chat_log_for_{self.unique_id}_{datetime.now().strftime("%Y-%m-%d_%H-%M-%S")}.json'
-        existing_files = self.search_file()
+        existing_files = search_file()
+        print(existing_files)
+        
         data = {
-            "Unique ID": self.unique_id,
-            "chat_history": self.chat_log_history
-        }
-
+                #"name": Name,
+                #"occupation": Occupation,
+                #"years of experience": YearsOfExp,
+                #"ethnicity": Ethnicity,
+                #"gender": Gender,
+                #"age": Age,
+                "Unique ID": self.unique_id,
+                "chat_history": self.chat_log_history
+                }
+        
         with open(self.chat_log_name, "w") as log_file:
-            json.dump(data, log_file, indent=4)
-
+                json.dump(data, log_file, indent=4)
+    
         if not existing_files:
+            # If the file does not exist, upload it
             file_metadata = {
                 'name': self.chat_log_name,
-                'parents': [self.folder_id],
-                'mimeType': 'application/json'
+                'parents': [self.folder_id],'mimeType': 'application/json'
             }
             media = MediaFileUpload(self.chat_log_name, mimetype='application/json')
             file = self.service.files().create(body=file_metadata, media_body=media, fields='id').execute()
             print(f"Uploaded new file with ID: {file.get('id')}")
         else:
+            print(f"File '{self.chat_log_name}' already exists.")
+            # Example: Update the file content
             file_id = existing_files[0]['id']
             media = MediaFileUpload(self.chat_log_name, mimetype='application/json')
             updated_file = self.service.files().update(fileId=file_id, media_body=media).execute()
             print(f"Updated existing file with ID: {updated_file.get('id')}")
 
-    def generate(self, prompt, history):
-        if not self.agreed:
-            output = "Please agree to the terms and conditions to start chatting."
-            self.chat_history.append(("System", output))
-        else:
+    def generate(self,prompt, history):
+            
+        #if not len(Name) == 0 and not len(Occupation) == 0 and not len(Ethnicity) == 0 and not len(Gender) == 0 and not len(Age) == 0 and not len(YearsOfExp):
+        if self.agreed:
+            firstmsg =""
             if self.isFirstRun:
                 self.context = self.initContext
                 self.isFirstRun = False
+                firstmsg = prompt
+                
+        
+            self.context += """
+                      <|im_start|>nurse
+                      Nurse:"""+prompt+"""
+                      <|im_start|>barry
+                      Barry:
+                      """
+        
+            response = ""
+            
+            while(len(response) < 1):
+                output = self.llm(context, max_tokens=400, stop=["Nurse:"], echo=False)
+                response = output["choices"][0]["text"]
+                response = response.strip()
+                #yield response
+        
+        
+          #  for output in llm(input, stream=True, max_tokens=100, ):
+            #    piece = output['choices'][0]['text']
+           #     response += piece
+           #     chatbot[-1] = (chatbot[-1][0], response)
+        
+           #     yield  response
+                
+            cleaned_response = self.strip_text(response)
+        
+            self.chat_history.append((prompt,cleaned_response))
+            if  not self.isFirstRun:
+                self.chat_log_history.append({"user": prompt, "bot": cleaned_response})
+                self.upload_to_google_drive()
+                
+            else:
+                self.chat_log_history.append({"user": firstmsg, "bot": cleaned_response})
+            
+            context += response
+            
+            print (context)
+            return self.chat_history
+            
+        else:
+            output = "Did you forget to Agree to the Terms and Conditions?"
+            self.chat_history.append((prompt,output))
+            return self.chat_history
 
-            cleaned_prompt = self.strip_text(prompt)
-            cleaned_response = f"Simulated response for: {cleaned_prompt}"  # Placeholder for actual model response
-
-            self.chat_history.append((cleaned_prompt, cleaned_response))
-            self.chat_log_history.append({"user": cleaned_prompt, "bot": cleaned_response})
-            self.upload_to_google_drive()
-
-        return self.chat_history
 
-    def reset_all(self):
+    def start_chat_button_fn(self,agree_status):
+        
+        if agree_status: 
+            self.agreed = agree_status
+            self.chat_log_name =  f'chat_log_for_{self.unique_id}_{datetime.now().strftime("%Y-%m-%d_%H-%M-%S")}.json'
+            return f"You can start chatting now"    
+        else:
+            return "You must agree to the terms and conditions to proceed"
+        
+    def reset_chat_interface(self):
         self.chat_history = []
         self.chat_log_history = []
         self.isFirstRun = True
-        self.unique_id = self.generate_unique_id()
-        print("All components have been reset.")
-        return "Reset completed."
-
-    def create_app(self):
-        with gr.Blocks() as app:
-            gr.Markdown("## Chatbot Interface")
-            agree_status = gr.Checkbox(label="I agree to the terms and conditions.")
-            chatbot_interface = gr.Chatbot()
-            msg_input = gr.Textbox(label="Type your message here")
-            send_button = gr.Button("Send")
-            reset_button = gr.Button("Reset")
-
-            def update_agreed_status(status):
-                self.agreed = status
-                return "You can now start chatting."
+        return "Chat has been reset."
+    
+    def reset_name_interface(self):
+        Name = ""
+        Occupation = ""
+        YearsOfExp = ""
+        Ethnicity = ""
+        Gender = ""
+        Age = ""
+        chat_log_name = ""
+        return "User info has been reset."
+    
+    def reset_all(self):
 
-            agree_status.change(update_agreed_status, inputs=[agree_status], outputs=[])
+        message1 = reset_chat_interface()
+        #message2 = reset_name_interface()
+        message3 = load_model()
+        self.unique_id = generate_unique_id()
+        return f"All Chat components have been rest.  Uniqe ID for this session is, {self.unique_id}. Please note this down.",self.unique_id
 
-            send_button.click(self.generate, inputs=[msg_input, chatbot_interface], outputs=chatbot_interface)
-            reset_button.click(self.reset_all, inputs=[], outputs=[])
 
+    def create_app(self):
+        with gr.Blocks() as app:
+            gr.Markdown("# ECU-IVADE: Conversational AI Model for Aggressive Patient Behavior (Beta Testing)")
+            unique_id_display = gr.Textbox(value=unique_id, label="Session Unique ID", interactive=False,show_copy_button = True)
+            
+            with gr.Tab("Terms and Conditions"):
+                #name = gr.Textbox(label="Name")
+                #occupation = gr.Textbox(label="Occupation")
+                #yearsofexp = gr.Textbox(label="Years of Experience")
+                #ethnicity = gr.Textbox(label="Ethnicity")
+                #gender = gr.Dropdown(choices=["Male", "Female", "Other", "Prefer Not To Say"], label="Gender")
+                #age = gr.Textbox(label="Age")
+                #submit_info = gr.Button("Submit")
+                gr.Markdown("## Terms and Conditions")
+                gr.Markdown("""
+            Before using our chatbot, please read the following terms and conditions carefully:
+            
+            - **Data Collection**: Our chatbot collects chat logs for the purpose of improving our services and user experience.
+            - **Privacy**: We ensure the confidentiality and security of your data, in line with our privacy policy.
+            - **Survey**: At the end of the chat session, you will be asked to participate in a short survey to gather feedback about your experience.
+            - **Consent**: By checking the box below and initiating the chat, you agree to these terms and the collection of chat logs, and consent to take part in the survey upon completing your session.
+            
+            Please check the box below to acknowledge your agreement and proceed.
+            """)
+                agree_status = gr.Checkbox(label="I have read and understand the terms and conditions.")
+                status_label = gr.Markdown()
+                start_chat_button = gr.Button("Start Chat with Chatlog")
+                #submit_info.click(submit_user_info, inputs=[name, occupation, yearsofexp, ethnicity, gender, age], outputs=[status_textbox])
+                start_chat_button.click(start_chat_button_fn, inputs=[agree_status], outputs=[status_label])
+                #status_textbox = gr.Textbox(interactive = False)
+                
+            with gr.Tab("Chat Bot"):
+                chatbot = gr.Chatbot()
+                msg = gr.Textbox(label="Type your message")
+                send = gr.Button("Send")
+                clear = gr.Button("Clear Chat")
+                send.click(generate, inputs=[msg], outputs=chatbot)
+                clear.click(lambda: chatbot.clear(), inputs=[], outputs=chatbot)
+            
+            with gr.Tab("Reset"):
+                reset_button = gr.Button("Reset ChatBot Instance")
+                reset_output = gr.Textbox(label="Reset Output", interactive=False)
+                reset_button.click(reset_all, inputs=[], outputs=[reset_output,unique_id_display])
         return app
 
-    def launch(self):
-        self.app.launch(debug=True)
-
-# Example usage
-repo_name = 'YourRepoName/YourModelName'
-model_file = "YourModelFileName"
-service_account_file = '/path/to/your/service_account_creds.json'
-folder_id = 'YourGoogleDriveFolderID'
-
-chatbot_app = ChatbotApp(repo_name, model_file, service_account_file, folder_id)
-chatbot_app.launch()
+llm = load_model()
+chatbot_app = ChatbotApp(llm,SERVICE_ACCOUNT_FILE,SCOPES,folder_id,unique_id,initContext)
+app = chatbot_app.create_app()
+app.launch(debug=True)