Update app.py

app.py

@@ -63,9 +63,17 @@ app.mount("/images", StaticFiles(directory="images"), name="images")
 
 # Gemini API Configuration
 API_KEY = os.getenv('AIzaSyDtLhhmXpy8ubSGb84ImaxM_ywlL0l_8bo')
+GEMINI_AVAILABLE = True
 if not API_KEY:
-    raise ValueError("GEMINI_API_KEY environment variable is not set")
-genai.configure(api_key=API_KEY)
+    logger.warning("GEMINI_API_KEY not set. Gemini-dependent features (chatbot, file QA fallback, summarization fallback, text generation) will be disabled.")
+    GEMINI_AVAILABLE = False
+else:
+    try:
+        genai.configure(api_key=API_KEY)
+        logger.info("Gemini API configured successfully")
+    except Exception as e:
+        logger.error(f"Failed to configure Gemini API: {str(e)}. Disabling Gemini features.")
+        GEMINI_AVAILABLE = False
 
 # Model configurations
 MODELS = {
@@ -118,6 +126,9 @@ def load_model(task: str, model_name: str = None):
         model_to_load = model_name or MODELS.get(task)
         
         if task == "chatbot":
+            if not GEMINI_AVAILABLE:
+                logger.warning("Gemini not available. Returning None for chatbot task.")
+                return None
             return genai.GenerativeModel(model_to_load)
             
         if task == "visual-qa":
@@ -156,10 +167,14 @@ def load_model(task: str, model_name: str = None):
 
 def get_gemini_response(user_input: str, is_generation: bool = False):
     """Function to generate response with Gemini for both chat and text generation"""
+    if not GEMINI_AVAILABLE:
+        return "Error: Gemini API is not available. Please contact the administrator."
     if not user_input:
         return "Please provide some input."
     try:
         chatbot = load_model("chatbot")
+        if not chatbot:
+            return "Error: Gemini API is not available."
         if is_generation:
             prompt = f"Generate creative text based on this prompt: {user_input}"
         else:
@@ -470,9 +485,12 @@ async def process_input(
                 final_summary = re.sub(r'\s+', ' ', final_summary).strip()
                 if not final_summary or final_summary.lower().startswith(content.lower()[:30]):
                     logger.warning("Summarizer produced inadequate output, falling back to Gemini")
-                    final_summary = get_gemini_response(
-                        f"Summarize this text in a concise and meaningful way: {content}"
-                    )
+                    if GEMINI_AVAILABLE:
+                        final_summary = get_gemini_response(
+                            f"Summarize this text in a concise and meaningful way: {content}"
+                        )
+                    else:
+                        final_summary = "Summarization fallback unavailable without Gemini API."
 
                 if not final_summary.endswith(('.', '!', '?')):
                     final_summary += '.'
@@ -482,9 +500,12 @@ async def process_input(
 
             except Exception as e:
                 logger.error(f"Summarization error: {str(e)}")
-                final_summary = get_gemini_response(
-                    f"Summarize this text in a concise and meaningful way: {content}"
-                )
+                if GEMINI_AVAILABLE:
+                    final_summary = get_gemini_response(
+                        f"Summarize this text in a concise and meaningful way: {content}"
+                    )
+                else:
+                    final_summary = "Summarization failed and Gemini fallback is unavailable."
                 return {"response": final_summary, "type": "summary", "message": "Text was preprocessed to correct spelling errors"}
             
         elif intent == "image-to-text":
@@ -537,11 +558,15 @@ async def process_input(
             if is_factual:
                 final_answer = answer
             else:
-                chatbot = load_model("chatbot")
-                if "fly" in question.lower():
-                    final_answer = chatbot.generate_content(f"Make this fun and spacey: {answer}").text.strip()
+                if GEMINI_AVAILABLE:
+                    chatbot = load_model("chatbot")
+                    if "fly" in question.lower():
+                        final_answer = chatbot.generate_content(f"Make this fun and spacey: {answer}").text.strip()
+                    else:
+                        final_answer = chatbot.generate_content(f"Make this cosmic and poetic: {answer}").text.strip()
                 else:
-                    final_answer = chatbot.generate_content(f"Make this cosmic and poetic: {answer}").text.strip()
+                    final_answer = answer
+                    logger.warning("Gemini unavailable for enhancing VQA answer")
             
             logger.info(f"Final VQA answer: {final_answer}")
             
@@ -572,9 +597,13 @@ async def process_input(
             return {"response": response, "type": "visualization_code"}
             
         elif intent == "text-generation":
-            response = get_gemini_response(text, is_generation=True)
-            lines = response.split(". ")
-            formatted_poem = "\n".join(line.strip() + ("." if not line.endswith(".") else "") for line in lines if line)
+            if GEMINI_AVAILABLE:
+                response = get_gemini_response(text, is_generation=True)
+                lines = response.split(". ")
+                formatted_poem = "\n".join(line.strip() + ("." if not line.endswith(".") else "") for line in lines if line)
+            else:
+                response = "Text generation is unavailable without Gemini API."
+                formatted_poem = response
             return {"response": formatted_poem, "type": "generated_text"}
             
         elif intent == "file-qa":
@@ -590,6 +619,15 @@ async def process_input(
             qa_pipeline = load_model("file-qa")
             if qa_pipeline is None:
                 logger.info("Using Gemini fallback for file-qa")
+                if not GEMINI_AVAILABLE:
+                    return {
+                        "response": "File QA is unavailable without Gemini API or a working QA model.",
+                        "type": "file_qa",
+                        "additional_data": {
+                            "question": text,
+                            "file_name": file.filename
+                        }
+                    }
                 question = text.strip()
                 if not question.endswith('?'):
                     question += '?'
@@ -627,8 +665,12 @@ async def process_input(
                 best_answer += '.'
             
             try:
-                chatbot = load_model("chatbot")
-                final_answer = chatbot.generate_content(f"Make this cosmic and poetic: {best_answer}").text.strip()
+                if GEMINI_AVAILABLE:
+                    chatbot = load_model("chatbot")
+                    final_answer = chatbot.generate_content(f"Make this cosmic and poetic: {best_answer}").text.strip()
+                else:
+                    final_answer = best_answer
+                    logger.warning("Gemini unavailable for enhancing file QA answer")
             except Exception as e:
                 logger.warning(f"Failed to add cosmic tone: {str(e)}. Using raw answer.")
                 final_answer = best_answer
@@ -816,12 +858,19 @@ async def home():
 @app.get("/health")
 async def health_check():
     """Health check endpoint"""
-    return {"status": "healthy", "version": "2.0.0"}
+    return {
+        "status": "healthy",
+        "version": "2.0.0",
+        "gemini_available": GEMINI_AVAILABLE
+    }
 
 @app.get("/models")
 async def list_models():
     """List available models"""
-    return {"models": MODELS}
+    available_models = MODELS.copy()
+    if not GEMINI_AVAILABLE:
+        available_models["chatbot"] = "disabled (Gemini API unavailable)"
+    return {"models": available_models}
 
 @app.on_event("startup")
 async def startup_event():
@@ -848,13 +897,11 @@ async def startup_event():
     except Exception as e:
         logger.error(f"Error pre-loading translation model: {str(e)}")
     
-    await asyncio.gather(
-        load_model_with_timeout("summarization"),
-        load_model_with_timeout("image-to-text"),
-        load_model_with_timeout("visual-qa"),
-        load_model_with_timeout("chatbot"),
-        load_model_with_timeout("file-qa")
-    )
+    tasks = ["summarization", "image-to-text", "visual-qa", "file-qa"]
+    if GEMINI_AVAILABLE:
+        tasks.append("chatbot")
+    
+    await asyncio.gather(*(load_model_with_timeout(task) for task in tasks))
 
 if __name__ == "__main__":
     import uvicorn