Update app.py

app.py

@@ -1,65 +1,183 @@
-from transformers import AutoModelForCausalLM, AutoTokenizer
 import gradio as gr
-import torch
+import os
+import random
+import time
+import numpy as np
 import json
 
+qs = {}
 
-title = "????AI ChatBot"
-description = "A State-of-the-Art Large-scale Pretrained Response generation model (DialoGPT)"
-examples = [["How are you?"]]
+theme = gr.themes.Base(
+    primary_hue="gray",
+    secondary_hue="gray",
+).set(
+    background_fill_primary_dark='*neutral_950',
+    background_fill_secondary_dark='*neutral_950'
+)
 
+from urllib.parse import parse_qs
+def parse_query_params(query_string):
+    parsed_params = parse_qs(query_string)
+    simplified_params = {k: v[0] if len(v) == 1 else v for k, v in parsed_params.items()}
+    return simplified_params
 
-tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-large")
-model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-large")
+def app_inits():
+    global qs
+    
+    # List of JSON file names
+    filenames = ['fileone.json', 'filesecond.json', 'filethird.json', 'filefourth.json', 'filefifth.json']
+
+    # Load data from each JSON file
+    for filename in filenames:
+        with open(filename, 'r') as file:
+            data = json.load(file)
+            qs.update(data)
+        
+    print("Loaded Q & A")
+    print("Keys:", list(qs.keys()))
+    print("CALL URL: http://127.0.0.1:7860/?dw=0.02&dl=0.0001")
+        
+    return    
+
+with gr.Blocks(theme = theme) as demo:
+    chatbot = gr.Chatbot(elem_id="chatbot", layout = "panel", avatar_images=("images/user.jpg", "images/bot.jpg"),)
+    
+    def get_params(request: gr.Request):        
+        headers = request.headers
+        host = request.client.host
+        user_agent = request.headers["user-agent"]
+        params = request.query_params
+        
+        return str(params)
+
+    with gr.Row(equal_height=True):
+        msg = gr.Textbox(show_label=False, placeholder="Message ChatGPT...", max_lines = 5,container = False,)
+        btn = gr.Button(value="", min_width=80, size = "lg", icon="images/button.jpg", scale= 0)
+        url_params = gr.State()
+     
+
+    demo.load(get_params, None, url_params, queue=False)
+
+    def user(user_message, history):
+        return "", history + [[user_message, None]]
+
+    def bot( history, url_params):
+        global qs
+        DelayBetweenWords = 0.1
+        DelayBetweenLetters = 0.0001
 
+        if url_params != "":
+            params = parse_query_params(url_params)
+            DelayBetweenWords = float(params.get("dw", DelayBetweenWords))
+            DelayBetweenLetters = float(params.get("dl", DelayBetweenLetters))
+        
+        keywords = list(qs.keys())
 
-def predict(input, history=[]):
-    new_user_input_ids = tokenizer.encode(
-        input + tokenizer.eos_token, return_tensors="pt"
+        text = history[-1][0]
+
+        file_location = 'images/log_data.txt'
+        full_path = os.path.abspath(file_location)
+
+        if text != "":
+           search_keyword = find_best_keyword_match(keywords, text)     
+        else:   
+           search_keyword = "None"
+
+        log_message("-ENTRY- [query]: " + text + " [params] " + url_params + " [keyword] " + search_keyword)
+        
+        if search_keyword == "None":
+           bot_message = "Sorry, don't know any information about this."
+        else:
+           output_text = qs.get(search_keyword, "Keyword identified. No information found.")
+           bot_message = output_text
+
+        if text == "debug":
+           bot_message = "[DEBUG (log file: " + full_path + " params: " + url_params + "\nWords Delay=" + str(DelayBetweenWords) +  " sec. Letters Delay=" + str(DelayBetweenLetters) + " sec.) \nKeys:\n" + "\n".join(keywords) + "]"
+
+        history[-1][1] = ""
+        
+        for character in bot_message:
+            history[-1][1] += character
+            
+            if character == " ":
+                time.sleep(DelayBetweenWords)
+            else: 
+                time.sleep(DelayBetweenLetters)
+
+            yield history
+    
+        log_message("-EXIT- [query]: " + text + " [params] " + url_params + " [keyword] " + search_keyword)
+
+    btn.click(user, [msg, chatbot], [msg, chatbot], queue=False, show_progress=False).then(
+        bot, [chatbot, url_params], chatbot, concurrency_limit=50
+    )
+    
+    msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False, show_progress=False).then(
+        bot, [chatbot, url_params], chatbot, concurrency_limit=50
     )
 
-    # append the new user input tokens to the chat history
-    bot_input_ids = torch.cat([torch.LongTensor(history), new_user_input_ids], dim=-1)
-
-    # generate a response
-    history = model.generate(
-        bot_input_ids, max_length=4000, pad_token_id=tokenizer.eos_token_id
-    ).tolist()
-
-    # convert the tokens to text, and then split the responses into lines
-    response = tokenizer.decode(history[0]).split("<|endoftext|>")
-    # print('decoded_response-->>'+str(response))
-    response = [
-        (response[i], response[i + 1]) for i in range(0, len(response) - 1, 2)
-    ]  # convert to tuples of list
-    # print('response-->>'+str(response))
-    return response, history
-
-def read_json_file(file_path): #read json file test
-    with open(file_path, 'r') as file:
-        data = json.load(file)
-    return data
-
-def main():
-    # List of file names
-    file_names = ['fileone.json', 'filesecond.json', 'filethird.json', 'filefourth.json', 'filefifth.json']
+def normalize(s):
+    """Lowercase and strip the string to normalize it."""
+    return s.lower().strip()
+
+def levenshtein_distance(s1, s2):
+    """Calculate the Levenshtein distance between two strings."""
+    if len(s1) < len(s2):
+        return levenshtein_distance(s2, s1)
+
+    if len(s2) == 0:
+        return len(s1)
+
+    previous_row = range(len(s2) + 1)
+    for i, c1 in enumerate(s1):
+        current_row = [i + 1]
+        for j, c2 in enumerate(s2):
+            insertions = previous_row[j + 1] + 1
+            deletions = current_row[j] + 1
+            substitutions = previous_row[j] + (c1 != c2)
+            current_row.append(min(insertions, deletions, substitutions))
+        previous_row = current_row
+    
+    return previous_row[-1]
+
+def find_best_keyword_match(keywords, text, max_distance=3):
+    """Find the best keyword match in the text, allowing for some misspelling."""
+    text_normalized = normalize(text)
+    best_match = None
+    lowest_distance = float('inf')
     
-    # Read each JSON file and print its content
-    for file_name in file_names:
-        json_data = read_json_file(file_name)
-        print(f"Contents of {file_name}:")
-        print(json_data)
-        print()
-
-if __name__ == "__main__":
-    main()
-
-gr.Interface(
-    fn=predict,
-    title=title,
-    description=description,
-    examples=examples,
-    inputs=["text", "state"],
-    outputs=["chatbot", "state"],
-    theme="finlaymacklon/boxy_violet",
-).launch()
+    for keyword in keywords:
+        keyword_normalized = normalize(keyword)
+        if ' ' in keyword_normalized:
+            slice_length = len(keyword_normalized)
+            for i in range(len(text_normalized) - slice_length + 1):
+                text_slice = text_normalized[i:i+slice_length]
+                distance = levenshtein_distance(text_slice, keyword_normalized)
+                if distance < lowest_distance:
+                    best_match = keyword
+                    lowest_distance = distance
+        else:
+            for word in text_normalized.split():
+                distance = levenshtein_distance(word, keyword_normalized)
+                if distance < lowest_distance:
+                    best_match = keyword
+                    lowest_distance = distance
+
+    if lowest_distance <= max_distance:
+        return best_match
+    return "None"
+
+from datetime import datetime
+
+filename = 'images/log_data.txt'
+
+def log_message(param):
+    timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    log_msg = f'{timestamp}: : {param}\n'
+    
+    with open(filename, 'a') as log_file:
+        log_file.write(log_msg)
+
+app_inits()    
+demo.queue()
+demo.launch(allowed_paths=["."], max_threads=40)