app.py

import requests
import datetime
import http.server
import websockets
import websocket
import asyncio
import sqlite3
import json
import gradio as gr
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

# 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))

# Function to send a question to the chatbot and get the response
async def askQuestion(question):
    try:
        response = requests.post(
            "https://flowiseai-flowise.hf.space/api/v1/prediction/522afa32-484c-471e-9ba5-4d6d2edfb89b",
            headers={"Content-Type": "application/json"},
            json={"question": message},
        )
        response_content = response.content.decode('utf-8')
     
        return response_content
    except Exception as e:
        print(e)


async def listen_for_messages():
    while True:
        if len(client_messages) > 0:
            # Get the latest client message
            client_message = client_messages[-1]
            try:
                server_message = server_responses[-1]
            except IndexError:
                # Handle the case when there are no server responses yet
                server_message = "connected successfully"
            
            return client_message, server_message
        else:
            # Handle the case when there are no client messages yet
            client_message = "connected successfully"
            server_message = "connected successfully"
            
            return client_message, server_message

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')
    while True:
        message = await ws.recv()
        message_copy = message
        client_messages.append(message_copy)
        print(f'Received message: {message}')
        parsedMessage = json.loads(message)        
        messageText = message
        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 = messages[-1]
            answer = await askQuestion(message)  # Use the message directly
            response = {'answer': answer}
            serverMessageText = response.get('answer', '')        
            await ws.send(json.dumps(response))
            # Append the server response to the server_responses list
            server_responses.append(serverMessageText)
            serverSender = 'server'
            db.execute('INSERT INTO messages (sender, message, timestamp) VALUES (?, ?, ?)',
                           (serverSender, serverMessageText, timestamp))
            db.commit()

        except websockets.exceptions.ConnectionClosedError as e:
            print(f"Connection closed: {e}")

        except Exception as e:
            print(f"Error: {e}")


# Function to stop the WebSocket server
def stop_websockets():
    global websocket_server
    if websocket_server:
        cursor.close()
        db.close()
        websocket_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)
    print(f"Starting WebSocket server on port {websocketPort}...")
    return "Used ports:\n" + '\n'.join(map(str, used_ports))

with gr.Blocks() as demo:
    
    with gr.Column(scale=1, min_width=600):   
        with gr.Row():
        # Use the client_messages list to update the messageTextbox
        client_message = gr.Textbox(lines=15, max_lines=130, label="Client inputs")     
        # Use the server_responses list to update the serverMessageTextbox
        server_message = 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():                  
        gui = gr.Button("connect interface")
        with gr.Row():   
        port = gr.Textbox()  
        startWebsockets.click(start_websockets, inputs=websocketPort, outputs=port)
        gui.click(listen_for_messages, inputs=None, outputs={client_message, server_message})      
        stopWebsockets.click(stop_websockets)

demo.queue()    
demo.launch(share=True)