Update app.py

app.py

@@ -1,126 +1,137 @@
-import requests
 import datetime
-import http.server
 import websockets
-import websocket
 import asyncio
 import sqlite3
 import json
+import requests
 import gradio as gr
+import PySimpleGUI as sg
 from bs4 import BeautifulSoup
 from gradio_client import Client
-import time
-
-client_messages = []
-server_responses = []
-messages = []
-used_ports = []
-
-websocket_server = None
-stop = asyncio.Future()
-
-# Global variables to store references to the textboxes
-messageTextbox = None
-serverMessageTextbox = None
-
-def slow_echo(message, history):
-    for i in range(len(message)):
-        time.sleep(0.3)
-        yield "You typed: " + message[: i+1]
-
-# Define a function to read the HTML file
-def read_html_file(file_name):
-    with open(file_name, 'r') as file:
-        html_content = file.read()
-    return html_content        
-
-# Set up the HTTP server
-class SimpleHTTPRequestHandler(http.server.SimpleHTTPRequestHandler):
-    def do_GET(self):
-        if self.path == '/':
-            self.send_response(200)
-            self.send_header('Content-type', 'text/html')
-            self.end_headers()
-            with open('index.html', 'rb') as file:
-                self.wfile.write(file.read())
-        else:
-            self.send_response(404)
-            self.end_headers()
-
-# Set up the SQLite database
-db = sqlite3.connect('chat-hub.db')
-cursor = db.cursor()
-cursor.execute('CREATE TABLE IF NOT EXISTS messages (id INTEGER PRIMARY KEY AUTOINCREMENT, sender TEXT, message TEXT, timestamp TEXT)')    
-db.commit()     
-
-# Define the function for sending an error message
-def sendErrorMessage(ws, errorMessage):
-    errorResponse = {'error': errorMessage}
-    ws.send(json.dumps(errorResponse))
-    
-# Define a function to ask a question to the chatbot and display the response
+from websockets.sync.client import connect
+
+modelPath = 'nlp-model.json'
+
+inputs = []
+client_ports = []
+
+layout = [
+    [sg.Multiline(size=(200, 10), key='-CLIENT-')],
+    [sg.Multiline(size=(100, 20), key='-INPUT-', auto_refresh=True), sg.Multiline(size=(100, 20), key='-OUTPUT-', auto_refresh=True)],
+    [sg.Multiline(size=(150, 2), key='-USERINPUT-')],
+    [sg.Button('Ask the agent')],
+    [sg.Text('Enter Port:'), sg.InputText(size=(10, 1), key='-PORT-'),
+     sg.Slider(range=(1000, 9999), orientation='h', size=(20, 20), key='-PORTSLIDER-')],
+    [sg.Button('Start WebSocket server'), sg.Button('Start WebSocket client')],
+    [sg.Button('Stop WebSocket server'), sg.Button('Stop WebSocket client')],  
+    [sg.Multiline(size=(20, 4), key='-SERVER_PORTS-')], [sg.Multiline(size=(20, 4), key='-CLIENT_PORTS-')],
+    [sg.Button('Clear Textboxes')]
+]
+
+def get_port(values):
+    if values['-PORT-']:
+        return int(values['-PORT-'])
+    else:
+        return int(values['-PORTSLIDER-'])
+
+window = sg.Window('WebSocket Client', layout)
+
+# Function to send a question to the chatbot and get the response
 async def askQuestion(question):
+    url = 'https://api.docsbot.ai/teams/ZrbLG98bbxZ9EFqiPvyl/bots/oFFiXuQsakcqyEdpLvCB/chat'
+    headers = {
+        'Content-Type': 'application/json'
+    }
+    data = {
+        'question': question,
+        'full_source': False
+    }
     try:
-        response = requests.post(
-            "https://flowiseai-flowise.hf.space/api/v1/prediction/8fd03bee-7752-484f-844f-bdae1e4cb4fe",
-            headers={"Content-Type": "application/json"},
-            json={"question": question},
-        )
-        response_content = response.content.decode('utf-8')
-        client_messages.append(response_content)
-        return response_content
-    except Exception as e:
-        print(e)
-        
-# Define a function to ask a question to the chatbot and display the response
+        response = requests.post(url, headers=headers, json=data)
+        responseText = response.content.decode('utf-8')     
+        return responseText
+
+    except requests.exceptions.RequestException as e:
+        # Handle request exceptions here
+        print(f"Request failed with exception: {e}")
+
 async def askQuestion2(question):
+   url = 'https://api.docsbot.ai/teams/ZrbLG98bbxZ9EFqiPvyl/bots/oFFiXuQsakcqyEdpLvCB/chat'
+    headers = {
+        'Content-Type': 'application/json'
+    }
+    data = {
+        'question': question,
+        'full_source': False
+    }
     try:
-        message = server_responses[-1]
-        url = "https://api.chaindesk.ai/datastores/query/clka5g9zc000drg6mxl671ekv"
-        payload = {"query": message,
-                  "topK":2
-        }
-        headers = {
-            "Authorization": "Bearer 5315cd7b-bb79-49bc-bca2-8bcc7b243504",
-            "Content-Type": "application/json"
-        }
-
-        response = requests.request("POST", url, json=payload, headers=headers)
-
-        print(response.text)
-        return response.text
-    except Exception as e:
-        print(e)    
+        response = requests.post(url, headers=headers, json=data)
+        responseText = response.content.decode('utf-8')     
+        return responseText
+
+    except requests.exceptions.RequestException as e:
+        # Handle request exceptions here
+        print(f"Request failed with exception: {e}")
+
+async def askQuestion3(question):
+    url = 'https://api.docsbot.ai/teams/ZrbLG98bbxZ9EFqiPvyl/bots/oFFiXuQsakcqyEdpLvCB/chat'
+    headers = {
+        'Content-Type': 'application/json'
+    }
+    data = {
+        'question': question,
+        'full_source': False
+    }
+    try:
+        response = requests.post(url, headers=headers, json=data)
+        responseText = response.content.decode('utf-8')     
+        return responseText
+
+    except requests.exceptions.RequestException as e:
+        # Handle request exceptions here
+        print(f"Request failed with exception: {e}")        
+
+async def run_agent(question):
+    os.environ["GOOGLE_CSE_ID"] = GOOGLE_CSE_ID
+    os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
+    os.environ["FIREWORKS_API_KEY"] = FIREWORKS_API_KEY
+
+    llm = Fireworks(model="accounts/fireworks/models/llama-v2-13b")
+    tools = load_tools(["google-search", "llm-math"], llm=llm)
+    agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True, return_intermediate_steps=True)
+
+    response = agent({"input": question})
+    return response["output"], response["intermediate_steps"]     
+    response_content = response.content.decode('utf-8')     
+    return response_content   
 
 async def handleWebSocket(ws):
     print('New connection')
-    await ws.send('Hello! You are now entering a chat room for AI agents working as instances of NeuralGPT. Keep in mind that you are speaking with another chatbot')
+    instruction = "Hello! You are now entering a chat room for AI agents working as instances of NeuralGPT - a project of hierarchical cooperative multi-agent framework. Keep in mind that you are speaking with another chatbot. Please note that you may choose to ignore or not respond to repeating inputs from specific clients as needed to prevent unnecessary traffic." 
+    greetings = {'instructions': instruction}
+    await ws.send(json.dumps(instruction))
     while True:
-        message = await ws.recv()
-        message_copy = message
-        client_messages.append(message_copy)
-        print(f'Received message: {message}')
-        messageText = message
-        messages.append(message)
+        message = await ws.recv()        
+        print(message)
+        client_messages.append(message)
         timestamp = datetime.datetime.now().isoformat()
         sender = 'client'
         db = sqlite3.connect('chat-hub.db')
         db.execute('INSERT INTO messages (sender, message, timestamp) VALUES (?, ?, ?)',
-                   (sender, messageText, timestamp))
-        db.commit()        
-        try:
-            message = client_messages[-1]
-            answer = await askQuestion(message)  # Use the message directly
-            messages.append(answer)
-            response = {'answer': answer}
-            serverMessageText = response.get('answer', '')        
-            await ws.send(json.dumps(response))
+                   (sender, message, timestamp))
+        db.commit()
+        try:           
+            response = await askQuestion(message)
+            serverResponse = f'server response:{response}'
             # Append the server response to the server_responses list
-            server_responses.append(serverMessageText)
+            server_responses.append(serverResponse)
+            timestamp = datetime.datetime.now().isoformat()
             serverSender = 'server'
             db.execute('INSERT INTO messages (sender, message, timestamp) VALUES (?, ?, ?)',
-                           (serverSender, serverMessageText, timestamp))
+                    (serverSender, serverResponse, timestamp))
             db.commit()
+            await ws.send(json.dumps(serverResponse))
+            return serverResponse
 
         except websockets.exceptions.ConnectionClosedError as e:
             print(f"Connection closed: {e}")
@@ -128,62 +139,166 @@ async def handleWebSocket(ws):
         except Exception as e:
             print(f"Error: {e}")
 
+async def handle_message(message):
+    print(f'Received message: {message}')
+    timestamp = datetime.datetime.now().isoformat()
+    sender = 'client'
+    db = sqlite3.connect('chat-hub.db')
+    db.execute('INSERT INTO messages (sender, message, timestamp) VALUES (?, ?, ?)',
+               (sender, message, timestamp))
+    db.commit()
+    try:
+        userMessage = f'User B:{message}'
+        response = await askQuestion(userMessage)
+        serverResponse = f'server response:{response}'
+        timestamp = datetime.datetime.now().isoformat()
+        serverSender = 'server'
+        db.execute('INSERT INTO messages (sender, message, timestamp) VALUES (?, ?, ?)',
+                (serverSender, serverResponse, timestamp))
+        db.commit()
+        return serverResponse
+    except Exception as e:
+        print(f"Error: {e}")
+
+# Define start_client function with a variable port
+async def start_client(clientPort):
+    uri = f'ws://localhost:{clientPort}'
+    client_ports.append(clientPort)
+    window['-CLIENT_PORTS-'].print(str(client_ports) + '\n')
+    async with websockets.connect(uri, create_protocol=handleClient) as websocket:
+        print("Connected to server at:", clientPort)
+        return "Used ports:\n" + '\n'.join(map(str, client_ports))
+        message = await websocket.recv()
+        inputMsg = "client: " + handle_message
+        window['-INPUT-'].print(str(inputMsg) + '\n')
+        print(message)
+        return message
+
+async def handleClient(websocket, path):
+        return client1_msg
+
+async def connect_docsbot(clientPort):
+    uri = f'ws://localhost:{clientPort}'
+    async with websockets.connect(uri) as websocket:
+        print("Connected to server at:", clientPort)
+        client_ports.append(clientPort)
+        window['-CLIENT_PORTS-'].print(str(client_ports) + '\n')
+        return "Used ports:\n" + '\n'.join(map(str, client_ports))
+        while True:
+            message = await websocket.recv()
+            inputMsg = "client: " + handle_message
+            window['-INPUT-'].print(str(inputMsg) + '\n')
+            print(message)
+            return message
+
+async def handleClient2(websocket, path):
+        return client2_msg
+        
+async def connect_agent(clientPort):
+    uri = f'ws://localhost:{clientPort}'
+    async with websockets.connect(uri, create_protocol=handleClient3) as websocket:
+        print("Connected to server at:", clientPort)
+        client_ports.append(clientPort)
+        return "Used ports:\n" + '\n'.join(map(str, client_ports))
+        message = await websocket.recv()
+        inputMsg = "client: " + handle_message
+        window['-INPUT-'].print(str(inputMsg) + '\n')
+        print(message)
+        return message
+
+async def handleClient3(websocket, path):
+        return client3_msg
 
 # Function to stop the WebSocket server
 def stop_websockets():
-    global websocket_server
-    if websocket_server:
+    global server
+    if server:
         cursor.close()
         db.close()
-        websocket_server.close()
+        server.close()
         print("WebSocket server stopped.")
     else:
         print("WebSocket server is not running.")    
 
 # Start the WebSocket server 
 async def start_websockets(websocketPort):
-    global messageTextbox, serverMessageTextbox, websocket_server
-    # Create a WebSocket client that connects to the server    
-      
-    await(websockets.serve(handleWebSocket, 'localhost', websocketPort))
-    used_ports.append(websocketPort)
+    global server
+    # Create a WebSocket client that connects to the server      
+    server = await(websockets.serve(handleWebSocket, 'localhost', websocketPort))
+    server_ports.append(websocketPort)
     print(f"Starting WebSocket server on port {websocketPort}...")
-    return "Used ports:\n" + '\n'.join(map(str, used_ports))
+    return "Used ports:\n" + '\n'.join(map(str, server_ports))
+    await stop
+    await server.close()
 
-async def start_client():
-    async with websockets.connect('ws://localhost:5000') as ws:        
-        while True:
-            # Listen for messages from the server            
-            server_message = await ws.recv()
-            server_responses.append(server_message)
-            messages.append(server_message)
-            client_response = await askQuestion2(server_message)
-            client_messages.append(client_response)
-            await ws.send(client_response)
-            return server_message
-            await asyncio.sleep(0.1)
+async def start_client(websocketPort):
+    uri = f'ws://localhost:{websocketPort}'
+    while True:
+        try:
+            async with websockets.connect(uri) as ws:
+                print("Connected to server at:", websocketPort)
+                while True:
+                    message = await ws.recv()
+                    print(message)
+                    response = await askQuestion(message)
+                    print(response)
+                    await ws.send(response)
+        except websockets.exceptions.ConnectionClosedOK:
+            print("Connection closed")
+            continue
+
+async def start_interface():
+    while True:
+        event, values = window.read()
+        if event in (sg.WIN_CLOSED, 'Stop WebSocket client'):
+            break
+        elif event == 'Start WebSocket server':
+            websocketPort = get_port(values)
+            loop = asyncio.get_event_loop()
+            loop.run_until_complete(start_websockets(websocketPort))
+        elif event == 'Start WebSocket client':
+            websocketPort = get_port(values)
+            loop = asyncio.get_event_loop()
+            loop.run_until_complete(start_client(websocketPort))
+        elif event == 'Ask the agent':
+            question = values['-USERINPUT-']
+            loop = asyncio.get_event_loop()
+            loop.run_until_complete(handle_user(question))
+        elif event == 'Clear Textboxes':
+            window['-INPUT-'].update('')
+            window['-OUTPUT-'].update('')
+            window['-USERINPUT-'].update('')
+
+    window.close()
 
 with gr.Blocks() as demo:
-    with gr.Tabs(elem_classes="tab-buttons") as tabs:
-        with gr.TabItem("Websocket Server", elem_id="websocket_server", id=0):
-            with gr.Column(scale=1, min_width=600):   
-                with gr.Row():
-                    # Use the client_messages list to update the messageTextbox
-                    client_msg = gr.Textbox(lines=15, max_lines=130, label="Client inputs")     
-                    # Use the server_responses list to update the serverMessageTextbox
-                    server_msg = gr.Textbox(lines=15, max_lines=130, label="Server responses")            
-                with gr.Row():
-                    websocketPort = gr.Slider(minimum=1000, maximum=9999, label="Websocket server port", interactive=True, randomize=False)
-                    startWebsockets = gr.Button("Start WebSocket Server")            
-                    stopWebsockets = gr.Button("Stop WebSocket Server")               
-                with gr.Row():    
-                    Bot1 = gr.Button("Bot 1")    
-                with gr.Row():
-                    gui = gr.Button("connect interface")
-                with gr.Row():   
-                    port = gr.Textbox()  
-                    startWebsockets.click(start_websockets, inputs=websocketPort, outputs=port)
-                    Bot1.click(askQuestion, inputs=client_msg, outputs=server_msg)                  
- 
-demo.queue()    
+    with gr.Row():
+        # Use the client_messages list to update the messageTextbox
+        client_msg = gr.Textbox(lines=15, max_lines=130, label="Client messages", interactive=False)     
+        # Use the server_responses list to update the serverMessageTextbox
+        server_msg = gr.Textbox(lines=15, max_lines=130, label="Server responses", interactive=False)                       
+    with gr.Row():
+        userInput = gr.Textbox(label="User Input")
+    with gr.Row():    
+        Bot = gr.Button("Ask Server")                
+    with gr.Row():
+        websocketPort = gr.Slider(minimum=1000, maximum=9999, label="Websocket server port", interactive=True, randomize=False)
+        startServer = gr.Button("Start WebSocket Server")            
+        stopWebsockets = gr.Button("Stop WebSocket Server")
+    with gr.Row():   
+        port = gr.Textbox()
+    with gr.Row():
+        clientPort = gr.Slider(minimum=1000, maximum=9999, label="Websocket server port", interactive=True, randomize=False)
+        startClient = gr.Button("Start WebSocket client")
+        stopClient = gr.Button("Stop WebSocket client")
+    with gr.Row():
+        PortInUse = gr.Textbox()    
+        startServer.click(start_websockets, inputs=websocketPort, outputs=port)
+        startClient.click(start_client, inputs=clientPort, outputs=[PortInUse, client_msg]).then(askQuestion, inputs=client_msg, outputs=server_msg)
+        stopWebsockets.click(stop_websockets, inputs=None, outputs=server_msg)
+        startInterface = gr.Button("Start GUI")
+        Bot.click(askQuestion, inputs=userInput, outputs=server_msg)        
+        startInterface.click(start_interface, inputs=None, outputs=None)
+
+demo.queue()
 demo.launch()