async generator working

app.py

@@ -79,55 +79,51 @@
 # 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
-
-logging.basicConfig(level=IMPORTANT_LEVEL_NUM, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
+from custom_logging import get_logger
 
+logger = get_logger(__name__)
 rasa_io_url = "https://clairify.ai/socket.io"
 theme = gr.themes.Default(primary_hue="cyan", secondary_hue="violet")
 
 with gr.Blocks(theme=theme) as demo:
 
-     # 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):
+    rasa_client = RasaSocketIOClient(rasa_io_url)
+    
+    async def interact_with_rasa(user_input):
         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
+        
+        is_first_message = True
+        
+        async for message in rasa_client.send_message(user_input):
+            
+            logger.important(f"Processing messages: {message}")
+            
+            if is_first_message:
+                new_entry = (user_input, message.get('text', ''))
+                is_first_message = False
+            else:
+                new_entry = (None, message.get('text', ''))
+            
+            chat_history.value.append(new_entry)
+            
+            yield "", chat_history.value
 
     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])
+    
+    msg.submit(interact_with_rasa, inputs=[msg], outputs=[msg, chatbot])
 
 if __name__ == "__main__":
     logger.important("Launching Gradio demo...")
     asyncio.run(demo.launch())
-
-

custom_logging.py

@@ -1,6 +1,5 @@
 import logging
 
-# Step 1: Define a new logging level
 IMPORTANT_LEVEL_NUM = 25
 logging.addLevelName(IMPORTANT_LEVEL_NUM, "IMPORTANT")
 
@@ -8,5 +7,10 @@ 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
+logging.Logger.important = important
+
+logging.basicConfig(level=IMPORTANT_LEVEL_NUM, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def get_logger(name):
+    return logging.getLogger(name)
+

rasa_socketio_client.py

@@ -93,25 +93,18 @@
 
 import asyncio
 import socketio
-import logging
-from custom_logging import IMPORTANT_LEVEL_NUM
+from custom_logging import get_logger
 
-# Configure logging
-logging.basicConfig(level=IMPORTANT_LEVEL_NUM)
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 class RasaSocketIOClient:
     def __init__(self, uri, update_chat_history_callback=None):
-        self.sio = socketio.AsyncClient(logger=False, engineio_logger=False)
-        self.response_event = asyncio.Event()
+        self.sio = socketio.AsyncClient(logger=True, engineio_logger=True)
         self.uri = uri
-        self.response = None
-        self.update_chat_history_callback = update_chat_history_callback
-        self.last_user_message = None
+        self.message_queue = asyncio.Queue()
         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.")
@@ -120,18 +113,10 @@ class RasaSocketIOClient:
         async def disconnect():
             logger.important("Disconnected from the server.")
 
-        self.sio.on('bot_uttered', self.on_message)
-
-    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()
+        @self.sio.on('bot_uttered')
+        async def on_message(data):
+            logger.debug(f"Socket ID: {self.sio.sid} Received response: {data}")
+            await self.message_queue.put(data)  # Put received message into the queue
 
     async def connect(self):
         try:
@@ -141,14 +126,16 @@ class RasaSocketIOClient:
             logger.error(f"Failed to connect to the server: {e}")
 
     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': user_message})  # Adjust as per your setup
+            await self.sio.emit('user_uttered', {'message': user_message})
             logger.important(f"Message sent: {user_message}")
-            await self.response_event.wait()  # Wait here until the response has been received
+            timeout = 1800 / 1000  # Timeout in seconds after the last message is received
+            while True:
+                try:
+                    data = await asyncio.wait_for(self.message_queue.get(), timeout)
+                    yield data
+                except asyncio.TimeoutError:
+                    break
         except Exception as e:
             logger.error(f"Failed to send message: {e}")
 
@@ -159,4 +146,5 @@ class RasaSocketIOClient:
         except Exception as e:
             logger.error(f"Failed to disconnect: {e}")
 
+