socketio is working

app.py

@@ -1,32 +1,132 @@
-import gradio as gr
-import requests
+# import gradio as gr
+# import requests
 
-with gr.Blocks() as demo:
-    chatbot = gr.Chatbot()
-    msg = gr.Textbox()
-    clear = gr.ClearButton([msg, chatbot])
+# theme=gr.themes.Default(primary_hue="cyan", secondary_hue="violet")
+
+# with gr.Blocks(theme=theme) as demo:
+#     chatbot = gr.Chatbot()
+#     msg = gr.Textbox(placeholder="Say Hi! to wake me up", show_label=False)
+#     clear = gr.ClearButton([msg, chatbot])
 
-    def interact_with_rasa(user_input, chat_history):
-        rasa_url = "https://clairify.ai/webhooks/rest/webhook"
-        payload = {"sender": "user", "message": user_input}
-        response = requests.post(rasa_url, json=payload)
+#     def interact_with_rasa(user_input, chat_history):
+#         rasa_url = "https://clairify.ai/webhooks/rest/webhook"
+#         payload = {"sender": "user", "message": user_input}
+#         response = requests.post(rasa_url, json=payload)
         
-        if response.status_code == 200:
-            rasa_response = response.json()
-            if rasa_response and len(rasa_response) > 0:
-                bot_responses = [msg.get("text", "") for msg in rasa_response]
-                chat_history.append((user_input, bot_responses[0]))
-                for response in bot_responses[1:]:
-                    chat_history.append((None, response))
-            else:
-                bot_responses = ["Error: Empty response from Rasa server."]
-        else:
-            bot_responses = ["Error: Unable to connect to Rasa server."]            
+#         if response.status_code == 200:
+#             rasa_response = response.json()
+#             if rasa_response and len(rasa_response) > 0:
+#                 bot_responses = [msg.get("text", "") for msg in rasa_response]
+#                 chat_history.append((user_input, bot_responses[0]))
+#                 for response in bot_responses[1:]:
+#                     chat_history.append((None, response))
+#             else:
+#                 bot_responses = ["Error: Empty response from Rasa server."]
+#         else:
+#             bot_responses = ["Error: Unable to connect to Rasa server."]            
         
-        return "", chat_history
+#         return "", chat_history
+
+#     msg.submit(interact_with_rasa, [msg, chatbot], [msg, chatbot])
+
+# if __name__ == "__main__":
+#     demo.launch()
+
+# import gradio as gr
+# import asyncio
+# from rasa_socketio_client import RasaSocketIOClient
+# import logging
+# from custom_logging import IMPORTANT_LEVEL_NUM
+
+# # Enable logging for the whole app
+# logging.basicConfig(level=IMPORTANT_LEVEL_NUM)
+# logger = logging.getLogger(__name__)
+
+# rasa_io_url = "https://clairify.ai/socket.io"
+# rasa_client = RasaSocketIOClient(rasa_io_url)
+
+# theme = gr.themes.Default(primary_hue="cyan", secondary_hue="violet")
+
+# async def interact_with_rasa(user_input, chat_history):
+#     if not rasa_client.sio.connected:
+#         await rasa_client.connect()
+#     payload = {"message": user_input}
+#     rasa_response = await rasa_client.send_message(payload)
+
+
+#     # if rasa_response:
+#     #     bot_utterances = []
+#     #     for key, value in rasa_response.items():
+#     #         bot_utterance = value.get("text", "")  # Accessing the "text" key of each value
+#     #         bot_utterances.append(bot_utterance)
+    
+#     #     if bot_utterances:
+#     #         chat_history.append((user_input, bot_utterances[0]))
+#     #         for utterance in bot_utterances[1:]:
+#     #             chat_history.append((None, utterance))
+#     # else:
+#     #     chat_history.append((user_input, "Error: Empty response from Rasa server."))
+#     chat_history.append((user_input, rasa_response["text"]))
+#     return "", chat_history
+
+# with gr.Blocks(theme=theme) as demo:
+#     chatbot = gr.Chatbot()
+#     msg = gr.Textbox(placeholder="Say Hi! to wake me up", show_label=False)
+#     clear = gr.ClearButton([msg, chatbot])
+
+#     msg.submit(interact_with_rasa, inputs=[msg, chatbot], outputs=[msg, chatbot])
+
+# if __name__ == "__main__":
+#     asyncio.run(demo.launch())
+
+
+import gradio as gr
+import asyncio
+from rasa_socketio_client import RasaSocketIOClient
+import logging
+from custom_logging import IMPORTANT_LEVEL_NUM
+
+# Assuming custom_logging.py defines the IMPORTANT_LEVEL_NUM and extends the Logger class
+# Enable logging for the whole app
+logging.basicConfig(level=IMPORTANT_LEVEL_NUM, format='%(asctime)s - %(levelname)s - %(name)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+rasa_io_url = "https://clairify.ai/socket.io"
+rasa_client = RasaSocketIOClient(rasa_io_url)
+
+theme = gr.themes.Default(primary_hue="cyan", secondary_hue="violet")
+
+async def interact_with_rasa(user_input, chat_history):
+    logger.important(f"User input received: {user_input}")
+    if not rasa_client.sio.connected:
+        logger.important("Rasa client not connected, attempting to connect...")
+        await rasa_client.connect()
+        if rasa_client.sio.connected:
+            logger.important("Rasa client successfully connected.")
+        else:
+            logger.important("Failed to connect to Rasa client.")
+            return "Error connecting to chat service, please try again later.", chat_history
+
+    payload = {"message": user_input}
+    logger.important(f"Sending payload to Rasa: {payload}")
+    rasa_response = await rasa_client.send_message(payload)
+
+    if rasa_response is None or "text" not in rasa_response:
+        logger.important(f"Invalid or None response from Rasa: {rasa_response}")
+        return "Received an invalid response from the chat service.", chat_history
+
+    logger.important(f"Rasa response: {rasa_response}")
+    chat_history.append((user_input, rasa_response["text"]))
+    return "", chat_history
+
+with gr.Blocks(theme=theme) as demo:
+    chatbot = gr.Chatbot()
+    msg = gr.Textbox(placeholder="Say Hi! to wake me up", show_label=False)
+    clear = gr.ClearButton([msg, chatbot])
 
-    msg.submit(interact_with_rasa, [msg, chatbot], [msg, chatbot])
+    msg.submit(interact_with_rasa, inputs=[msg, chatbot], outputs=[msg, chatbot])
 
 if __name__ == "__main__":
-    demo.launch()
+    logger.important("Launching Gradio demo...")
+    asyncio.run(demo.launch())
 

custom_logging.py

@@ -0,0 +1,12 @@
+import logging
+
+# Step 1: Define a new logging level
+IMPORTANT_LEVEL_NUM = 25
+logging.addLevelName(IMPORTANT_LEVEL_NUM, "IMPORTANT")
+
+def important(self, message, *args, **kws):
+    if self.isEnabledFor(IMPORTANT_LEVEL_NUM):
+        self._log(IMPORTANT_LEVEL_NUM, message, args, **kws)
+
+# Add the custom level to the logging.Logger class
+logging.Logger.important = important

rasa_socketio_client.py

@@ -0,0 +1,141 @@
+# import asyncio
+# import socketio
+# import logging
+
+# # Configure logging
+# logging.basicConfig(level=logging.DEBUG)
+# logger = logging.getLogger(__name__)
+
+# class RasaSocketIOClient:
+#     def __init__(self, uri):
+#         self.sio = socketio.AsyncClient(logger=True, engineio_logger=True)  # Enable internal logging
+#         self.uri = uri
+#         self.response = None
+
+#         @self.sio.on('bot_uttered')  # Adjust the event name as per your Rasa setup
+#         async def on_message(data):
+#             logger.info("Received response: %s", data)
+#             self.response = data  # Store the latest response
+
+#     async def connect(self):
+#         try:
+#             await self.sio.connect(self.uri)
+#             logger.info("Successfully connected to the server.")
+#         except Exception as e:
+#             logger.error("Failed to connect to the server: %s", e)
+
+#     async def send_message(self, message):
+#         self.response = None  # Reset previous response
+#         try:
+#             await self.sio.emit('user_uttered', message)  # Adjust the event name as per your Rasa setup
+#             logger.debug("Message sent: %s", message)
+#             await asyncio.sleep(1)  # Wait for the response to be received
+#         except Exception as e:
+#             logger.error("Failed to send message: %s", e)
+#         return self.response
+
+#     async def disconnect(self):
+#         try:
+#             await self.sio.disconnect()
+#             logger.info("Disconnected from the server.")
+#         except Exception as e:
+#             logger.error("Failed to disconnect: %s", e)
+
+
+# import asyncio
+# import socketio
+# import logging
+# from custom_logging import IMPORTANT_LEVEL_NUM 
+
+# logger = logging.getLogger(__name__)
+
+# class RasaSocketIOClient:
+#     def __init__(self, uri):
+#         self.sio = socketio.AsyncClient(logger=False, engineio_logger=False)
+#         self.response_event = asyncio.Event()
+#         self.uri = uri
+#         self.response = None
+
+#         @self.sio.on('bot_uttered')  # Adjust the event name as per your Rasa setup
+#         async def on_message(data):
+#             # Use the new logging level
+#             logger.important("Socket ID: %s Received response: %s", self.sio.sid, data)
+#             self.response = data  # Store the latest response
+
+#     async def connect(self):
+#         try:
+#             await self.sio.connect(self.uri)
+#             # Use the new logging level
+#             logger.important("Successfully connected to the server.")
+#         except Exception as e:
+#             # Use the new logging level for errors too, for consistency
+#             logger.important("Failed to connect to the server: %s", e)
+#             return "Failed to connect to the server."
+
+#     async def send_message(self, message):
+#         self.response = None  # Reset previous response
+#         try:
+#             await self.sio.emit('user_uttered', message)  # Adjust the event name as per your Rasa setup
+#             # Since this is more of a debug level, consider if you want to keep it under IMPORTANT or not
+#             logger.important("Message sent: %s", message)
+#             await asyncio.sleep(1)  # Wait for the response to be received
+#         except Exception as e:
+#             logger.important("Failed to send message: %s", e)
+#         return self.response
+
+#     async def disconnect(self):
+#         try:
+#             await self.sio.disconnect()
+#             logger.important("Disconnected from the server.")
+#         except Exception as e:
+#             logger.important("Failed to disconnect: %s", e)
+
+
+import asyncio
+import socketio
+import logging
+from custom_logging import IMPORTANT_LEVEL_NUM
+
+# Configure logging
+logging.basicConfig(level=IMPORTANT_LEVEL_NUM)
+logger = logging.getLogger(__name__)
+
+class RasaSocketIOClient:
+    def __init__(self, uri):
+        self.sio = socketio.AsyncClient(logger=False, engineio_logger=False)
+        self.response_event = asyncio.Event()
+        self.uri = uri
+        self.response = None
+
+        @self.sio.on('bot_uttered')  # Adjust the event name as per your Rasa setup
+        async def on_message(data):
+            # Use the new logging level
+            logger.important("Socket ID: %s Received response: %s", self.sio.sid, data)
+            self.response = data  # Store the latest response
+            self.response_event.set()  # Signal that response has been received
+
+    async def connect(self):
+        try:
+            await self.sio.connect(self.uri)
+            logger.important("Successfully connected to the server.")
+        except Exception as e:
+            logger.important("Failed to connect to the server: %s", e)
+            return "Failed to connect to the server."
+
+    async def send_message(self, message):
+        self.response = None  # Reset previous response
+        self.response_event.clear()  # Reset the event for a new message
+        try:
+            await self.sio.emit('user_uttered', message)  # Adjust the event name as per your Rasa setup
+            logger.important("Message sent: %s", message)
+            await self.response_event.wait()  # Wait here until the response has been received
+        except Exception as e:
+            logger.important("Failed to send message: %s", e)
+        return self.response
+
+    async def disconnect(self):
+        try:
+            await self.sio.disconnect()
+            logger.important("Disconnected from the server.")
+        except Exception as e:
+            logger.important("Failed to disconnect: %s", e)