Update utils/chatbot_interface.py

utils/chatbot_interface.py

@@ -1,36 +1,92 @@
-    def conversation(self, query: str, history: list) -> list:
-        """
-        Function to handle the chatbot interaction and maintain conversation history.
-        :param query: The user query to respond to.
-        :param history: The conversation history (list of [input, output] pairs).
-        :return: Updated conversation history.
-        """
-        logging.info("Received query: %s", query)
-
-        # Validate the query
-        if not query.strip():
-            logging.warning("Empty or invalid query received.")
-            history.append((query, "Please enter a valid query."))
-            return history
-
-        try:
-            # Generate a response using the create_response method
-            logging.info("Generating response for the query...")
-            response = self.create_response(
-                query=query,
-                model=self.DEFAULT_MODEL,
-                temperature=self.DEFAULT_TEMPERATURE,
-                max_output_tokens=self.DEFAULT_MAX_OUTPUT_TOKENS,
-                max_num_results=self.DEFAULT_MAX_NUM_RESULTS
+import os
+import json
+import logging
+import gradio as gr
+from utils.response_manager import ResponseManager 
+
+class ChatbotInterface:
+    def __init__(self, config_path: str = 'config/gradio_config.json'):
+        """
+        Initialize the ChatbotInterface with configuration.
+        :param config_path: Path to the configuration JSON file.
+        """
+        self.config = self.load_config(config_path)
+        self.title = self.config["chatbot_title"]
+        self.description = self.config["chatbot_description"]
+        self.input_label = self.config["chatbot_input_label"]
+        self.input_placeholder = self.config["chatbot_input_placeholder"]
+        self.output_label = self.config["chatbot_output_label"]
+        self.reset_button = self.config["chatbot_reset_button"]
+        self.submit_button = self.config["chatbot_submit_button"]
+        self.response_manager = ResponseManager()
+        self.conversation = self.response_manager.conversation  # Shortcut to the conversation method
+        logging.info("ChatbotInterface initialized with configuration.")
+
+    @staticmethod
+    def load_config(config_path: str) -> dict:
+        """
+        Load the configuration for Gradio GUI interface from the JSON file.
+        :param config_path: Path to the configuration JSON file.
+        :return: Configuration dictionary.
+        """
+        logging.info(f"Loading configuration from {config_path}...")
+        if not os.path.exists(config_path):
+            logging.error(f"Configuration file not found: {config_path}")
+            raise FileNotFoundError(f"Configuration file not found: {config_path}")
+
+        with open(config_path, 'r') as config_file:
+            config = json.load(config_file)
+
+        required_keys = [
+            "chatbot_title", "chatbot_description", "chatbot_input_label",
+            "chatbot_input_placeholder", "chatbot_output_label",
+            "chatbot_reset_button", "chatbot_submit_button"
+        ]
+        for key in required_keys:
+            if key not in config:
+                logging.error(f"Missing required configuration key: {key}")
+                raise ValueError(f"Missing required configuration key: {key}")
+
+        logging.info("Configuration loaded successfully.")
+        return config
+
+    def reset_output(self) -> list:
+        """
+        Reset the chatbot output.
+        :return: An empty list to reset the output.
+        """
+        return []
+
+    def create_interface(self) -> gr.Blocks:
+        """
+        Create the Gradio Blocks interface.
+        :return: A Gradio Blocks interface object.
+        """
+        logging.info("Creating Gradio interface...")
+
+        # Define the Gradio Blocks interface
+        with gr.Blocks() as demo:
+            gr.Markdown(f"## {self.title}\n{self.description}")
+
+            # Chatbot history component
+            chatbot_output = gr.Chatbot(label=self.output_label)
+
+            # User input
+            user_input = gr.Textbox(
+                lines=2,
+                label=self.input_label,
+                placeholder=self.input_placeholder
             )
 
-            # Append the query and response to the conversation history
-            history.append((query, response))
-            logging.info("Response generated successfully.")
-            return history
+            # Buttons
+            with gr.Row():
+                reset = gr.Button(self.reset_button, variant="secondary")
+                submit = gr.Button(self.submit_button, variant="primary")
+
+            # Button actions
+            submit.click(fn=self.conversation, inputs=[user_input, chatbot_output], outputs=chatbot_output)
+            user_input.submit(fn=self.conversation, inputs=[user_input, chatbot_output], outputs=chatbot_output)
+            reset.click(fn=self.reset_output, inputs=None, outputs=chatbot_output)
 
-        except Exception as e:
-            # Log the error and append it to the conversation history
-            logging.error("An error occurred while generating a response: %s", str(e))
-            history.append((query, f"An error occurred: {str(e)}"))
-            return history
+        logging.info("Gradio interface created successfully.")
+        return demo