working callback function

app.py

@@ -86,47 +86,48 @@ 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')
+logging.basicConfig(level=IMPORTANT_LEVEL_NUM, format='%(asctime)s - %(levelname)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()
+
+     # Initialize chat history as a gr.State object
+    chat_history = gr.State([])
+
+    # Instantiate RasaSocketIOClient with the update_chat_history callback
+    rasa_client = RasaSocketIOClient(rasa_io_url, update_chat_history_callback=update_chat_history)
+
+    # Define the callback function for updating chat history
+    async def update_chat_history(user_input, bot_response):
+        global chat_history  # Ensure chat_history is accessible and can be updated
+        new_entry = (user_input, bot_response)
+        current_history = chat_history.value
+        updated_history = current_history + [new_entry]
+        chat_history.value = updated_history  # Update the state with the new history
+        logger.important(f"Chat history updated with new entry: {chat_history.value}")
+
+    async def interact_with_rasa(user_input, chatbot):
+        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()
+        
+        logger.important(f"Sending payload to Rasa: {user_input}")
+        # Send the user message to Rasa; chat history will be updated via callback
+        await rasa_client.send_message(user_input)
+        # No need to manually update chat history here
+        return "", chatbot  # Return an empty string to clear the input field
+
+    chatbot = gr.Chatbot(label="Conversation")
     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__":
     logger.important("Launching Gradio demo...")
     asyncio.run(demo.launch())
 
+

rasa_socketio_client.py

@@ -101,41 +101,62 @@ logging.basicConfig(level=IMPORTANT_LEVEL_NUM)
 logger = logging.getLogger(__name__)
 
 class RasaSocketIOClient:
-    def __init__(self, uri):
+    def __init__(self, uri, update_chat_history_callback=None):
         self.sio = socketio.AsyncClient(logger=False, engineio_logger=False)
         self.response_event = asyncio.Event()
         self.uri = uri
         self.response = None
+        self.update_chat_history_callback = update_chat_history_callback
+        self.last_user_message = None
+        self.register_event_handlers()
+
+    def register_event_handlers(self):
+        # Use a method to define event handlers where 'self' is properly defined
+        @self.sio.event
+        async def connect():
+            logger.important("Connected to the server.")
+
+        @self.sio.event
+        async def disconnect():
+            logger.important("Disconnected from the server.")
+
+        self.sio.on('bot_uttered', self.on_message)
 
-        @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 on_message(self, data):
+        logger.important(f"Socket ID: {self.sio.sid} Received response: {data}")
+        # Check if there is a callback function defined and last user message is stored
+        if self.update_chat_history_callback and self.last_user_message is not None:
+            # Call the callback function with the last user message and bot's response
+            asyncio.create_task(self.update_chat_history_callback(self.last_user_message, data['text']))
+            logger.important("Callback task created for update_chat_history_callback.")
+        self.response = data
+        self.last_user_message = None  # Clear the last user message after handling
+        self.response_event.set()
 
     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."
+            logger.error(f"Failed to connect to the server: {e}")
 
-    async def send_message(self, message):
+    async def send_message(self, user_message):
+        # Store the user's message to use it later in the callback
+        self.last_user_message = user_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.sio.emit('user_uttered', {'message': user_message})  # Adjust as per your setup
+            logger.important(f"Message sent: {user_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
+            logger.error(f"Failed to send message: {e}")
 
     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)
+            logger.error(f"Failed to disconnect: {e}")
+
+