modified

app.py

@@ -6,9 +6,10 @@ import base64
 from io import BytesIO
 import os
 import logging
+import tempfile
 
-# Set up logger
-logger = logging.getLogger(_name_)
+# Logging Setup
+logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
 console_handler = logging.StreamHandler()
 file_handler = logging.FileHandler('chatbot_log.log')
@@ -19,86 +20,93 @@ logger.addHandler(console_handler)
 logger.addHandler(file_handler)
 
 # Initialize Groq Client
-client = Groq(api_key=os.getenv("GROQ_API_KEY_2"))
+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)
 
-# Function to encode the image
+# Function to encode 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")  # Ensure the correct format
-        logger.debug("Image encoding complete.")
+        uploaded_image.save(buffered, format="PNG")
         return base64.b64encode(buffered.getvalue()).decode("utf-8")
     except Exception as e:
         logger.error(f"Error encoding image: {e}")
         raise
 
-# Function to handle text and image inputs
+# Function to handle user input
 def customLLMBot(user_input, uploaded_image, chat_history):
     try:
-        logger.info("Processing input...")
+        # Check for valid inputs
+        if not user_input.strip() and uploaded_image is None:
+            raise ValueError("Either text input or an image is required.")
 
         # 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 for processing...")
-            # Send the image message to the Groq API
+            logger.info("Sending image to 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 the reply
+        # Extract response
         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 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}")
+        # 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}")
 
-        # Return the chat history (all Q&A) and the audio file
+        # Return chat history and audio file
         return [(entry[0], entry[1]) for entry in chat_history], audio_file
 
     except Exception as e:
-        # Handle errors gracefully
-        logger.error(f"Error in customLLMBot function: {e}")
+        logger.error(f"Error in customLLMBot: {e}")
         return [("User", 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():
@@ -153,6 +161,5 @@ def chatbot_ui():
 
     return demo
 
-
 # Launch the interface
-chatbot_ui().launch(server_name="0.0.0.0", server_port=7860)
+chatbot_ui().launch(server_name="0.0.0.0", server_port=7860)