modified

app.py

@@ -6,9 +6,8 @@ import base64
 from io import BytesIO
 import os
 import logging
-import tempfile
 
-# Logging Setup
+# Set up logger
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
 console_handler = logging.StreamHandler()
@@ -20,97 +19,90 @@ logger.addHandler(console_handler)
 logger.addHandler(file_handler)
 
 # Initialize Groq Client
-api_key = os.getenv("GROQ_API_KEY_2")
-if not api_key:
-    logger.error("GROQ_API_KEY_2 environment variable is not set. Exiting...")
-    raise EnvironmentError("Missing GROQ_API_KEY_2 environment variable.")
-client = Groq(api_key=api_key)
+client = Groq(api_key=os.getenv("GROQ_API_KEY_2"))
 
-# Function to encode image
+# Function to encode the image
 def encode_image(uploaded_image):
     try:
-        if not uploaded_image:
-            raise ValueError("No image provided.")
         logger.debug("Encoding image...")
         buffered = BytesIO()
-        uploaded_image.save(buffered, format="PNG")
+        uploaded_image.save(buffered, format="PNG")  # Ensure the correct format
+        logger.debug("Image encoding complete.")
         return base64.b64encode(buffered.getvalue()).decode("utf-8")
     except Exception as e:
         logger.error(f"Error encoding image: {e}")
         raise
 
-# Function to handle user input
+# Function to handle text and image inputs
 def customLLMBot(user_input, uploaded_image, chat_history):
     try:
-        # Check for valid inputs
-        if not user_input.strip() and uploaded_image is None:
-            raise ValueError("Either text input or an image is required.")
+        logger.info("Processing input...")
 
         # Append user input to the chat history
         chat_history.append(("User", user_input))
 
-        # Process image if provided
         if uploaded_image is not None:
+            # Encode the image to base64
             base64_image = encode_image(uploaded_image)
-            logger.debug(f"Encoded image size: {len(base64_image)} bytes")
 
+            # Log the image size and type
+            logger.debug(f"Image received, size: {len(base64_image)} bytes")
+
+            # Create a message specifically for image prompts
             messages = [
                 {
                     "role": "user",
                     "content": [
                         {"type": "text", "text": "What's in this image?"},
-                        {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{base64_image}"}}
-                    ]
+                        {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{base64_image}"}}]
                 }
             ]
-            logger.info("Sending image to Groq API...")
+
+            logger.info("Sending image to Groq API for processing...")
+            # Send the image message to the Groq API
             response = client.chat.completions.create(
                 model="llama-3.2-11b-vision-preview",
                 messages=messages,
             )
+            logger.info("Image processed successfully.")
         else:
             # Process text input
+            logger.info("Processing text input...")
             messages = [
                 {"role": "system", "content": "You are Dr. HealthBuddy, a professional virtual doctor chatbot."},
                 {"role": "user", "content": user_input},
             ]
-            logger.info("Sending text to Groq API...")
             response = client.chat.completions.create(
                 model="llama-3.2-11b-vision-preview",
                 messages=messages,
             )
+            logger.info("Text processed successfully.")
 
-        # Extract response
+        # Extract the reply
         LLM_reply = response.choices[0].message.content
         logger.debug(f"LLM reply: {LLM_reply}")
+
+        # Append the bot's response to the chat history
         chat_history.append(("Bot", LLM_reply))
 
-        # Generate audio response
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_audio:
-            tts = gTTS(LLM_reply, lang='en')
-            tts.save(tmp_audio.name)
-            audio_file = tmp_audio.name
-        logger.info(f"Audio response saved: {audio_file}")
+        # Generate audio for response
+        audio_file = f"response_{uuid.uuid4().hex}.mp3"
+        tts = gTTS(LLM_reply, lang='en')
+        tts.save(audio_file)
+        logger.info(f"Audio response saved as {audio_file}")
 
-        # Return chat history and audio file
-        return [(entry[0], entry[1]) for entry in chat_history], audio_file
+        # Return chat history as a list of tuples (sender, message)
+        return [(entry[1], entry[0]) for entry in chat_history], audio_file
 
     except Exception as e:
-        logger.error(f"Error in customLLMBot: {e}")
-        return [("User", f"An error occurred: {e}")], None
+        # Handle errors gracefully
+        logger.error(f"Error in customLLMBot function: {e}")
+        return [(user_input or "Image uploaded", f"An error occurred: {e}")], None
 
-# Cleanup Function for Audio
-def cleanup_audio(audio_file):
-    try:
-        if os.path.exists(audio_file):
-            os.remove(audio_file)
-            logger.info(f"Cleaned up audio file: {audio_file}")
-    except Exception as e:
-        logger.warning(f"Failed to delete audio file {audio_file}: {e}")
 
 # Gradio Interface
 def chatbot_ui():
-    chat_history = []  # Initialize empty chat history for the session
+    chat_history = []  # Initialize empty chat history
 
     with gr.Blocks() as demo:
         gr.Markdown("# Healthcare Chatbot Doctor")
@@ -151,15 +143,17 @@ def chatbot_ui():
             outputs=[chatbot, audio_output, user_input],
         )
 
-        # Action for clearing all fields and resetting chat history
-        def clear_chat():
-            nonlocal chat_history
-            chat_history = []  # Reset chat history for new session
-            return [], "", None, None
-
-        clear_btn.click(clear_chat, inputs=[], outputs=[chatbot, user_input, uploaded_image, audio_output])
+        # Action for clearing all fields
+        clear_btn.click(
+            lambda: ([], "", None, None),
+            inputs=[],
+            outputs=[chatbot, user_input, uploaded_image, audio_output],
+        )
 
     return demo
 
+
 # Launch the interface
 chatbot_ui().launch(server_name="0.0.0.0", server_port=7860)
+
+#chatbot_ui().launch(server_name="localhost", server_port=7860)