fix 3

Author: VedantAndhale

app/core/simple_config.py

@@ -45,6 +45,18 @@ def validate_required_fields(self) -> None:
 
         if missing_fields:
             raise ValueError(f"Missing required environment variables: {', '.join(missing_fields)}")
+    
+    def has_whatsapp_config(self) -> bool:
+        """Check if all WhatsApp configuration is available."""
+        required = [
+            self.PHONE_NUMBER_ID,
+            self.ACCESS_TOKEN_LTM,
+            self.CALLBACK_URL,
+            self.VERIFY_TOKEN,
+            self.APP_ID,
+            self.APP_SECRET,
+        ]
+        return all(required)
 
 
 # Try to use pydantic-settings, fall back to simple settings

app/main.py

@@ -42,34 +42,59 @@ def create_app() -> FastAPI:
     )
 
     # Initialize WhatsApp bot service if available
+    bot_service = None
     if WHATSAPP_AVAILABLE:
         try:
             from app.services.whatsapp_bot import WhatsAppBotService
             bot_service = WhatsAppBotService(app)
-            print("✅ WhatsApp bot service initialized successfully")
+            print("✅ WhatsApp bot service created (lazy initialization)")
         except Exception as e:
-            print(f"⚠️ Failed to initialize WhatsApp bot service: {e}")
+            print(f"⚠️ Failed to create WhatsApp bot service: {e}")
     else:
         print("⚠️ WhatsApp bot service not available - running in API-only mode")
 
+    @app.on_event("startup")
+    async def startup_event():
+        """Initialize services on startup."""
+        if bot_service:
+            # Try to initialize WhatsApp in the background
+            try:
+                if bot_service.initialize_whatsapp():
+                    print("✅ WhatsApp service initialized on startup")
+                else:
+                    print("⚠️ WhatsApp service initialization failed")
+            except Exception as e:
+                print(f"⚠️ WhatsApp service startup error: {e}")
+    
     @app.get("/")
     async def health_check():
         """Health check endpoint."""
+        whatsapp_status = False
+        if bot_service:
+            whatsapp_status = bot_service.is_initialized
+            
         return {
             "status": "healthy", 
             "message": "Crop Disease Detection Bot is running",
             "version": "1.0.0",
-            "whatsapp_enabled": WHATSAPP_AVAILABLE
+            "whatsapp_enabled": WHATSAPP_AVAILABLE,
+            "whatsapp_initialized": whatsapp_status
         }
 
     @app.get("/health")
     async def detailed_health_check():
         """Detailed health check endpoint."""
         components = {
             "api": "active",
-            "whatsapp_bot": "active" if WHATSAPP_AVAILABLE else "disabled",
+            "whatsapp_bot": "disabled",
         }
 
+        if WHATSAPP_AVAILABLE:
+            if bot_service and bot_service.is_initialized:
+                components["whatsapp_bot"] = "active"
+            else:
+                components["whatsapp_bot"] = "available_but_not_initialized"
+        
         try:
             # Try to check if ML model can be loaded
             from app.models.prediction import predict_image
@@ -84,6 +109,23 @@ async def detailed_health_check():
             "components": components
         }
 
+    @app.post("/initialize-whatsapp")
+    async def initialize_whatsapp_endpoint():
+        """Manually initialize WhatsApp service."""
+        if not WHATSAPP_AVAILABLE:
+            return {"status": "error", "message": "WhatsApp dependencies not available"}
+        
+        if not bot_service:
+            return {"status": "error", "message": "WhatsApp bot service not created"}
+        
+        try:
+            if bot_service.initialize_whatsapp():
+                return {"status": "success", "message": "WhatsApp service initialized"}
+            else:
+                return {"status": "error", "message": "WhatsApp initialization failed"}
+        except Exception as e:
+            return {"status": "error", "message": f"WhatsApp initialization error: {str(e)}"}
+    
     return app
 
 

app/services/whatsapp_bot.py

@@ -12,13 +12,16 @@
     MODEL_AVAILABLE = True
 except ImportError:
     MODEL_AVAILABLE = False
+    predict_image = None
     print("Warning: ML model not available")
 
 try:
     from app.data.disease_info import return_info, cart
     DATA_AVAILABLE = True
 except ImportError:
     DATA_AVAILABLE = False
+    return_info = None
+    cart = None
     print("Warning: Disease info data not available")
 
 
@@ -30,31 +33,56 @@ def __init__(self, app):
         self.app = app
         self.user_languages: Dict[str, str] = {}
         self.translator = Translator()
+        self.wa = None
+        self.is_initialized = False
+        self.settings = get_settings()
 
-        # Get settings
-        settings = get_settings()
+        # Don't initialize WhatsApp immediately - do it lazily
+        logging.info("WhatsApp bot service created (lazy initialization)")
+    
+    def _ensure_whatsapp_initialized(self) -> bool:
+        """Ensure WhatsApp client is initialized. Returns True if successful."""
+        if self.is_initialized and self.wa is not None:
+            return True
+            
+        # Check if WhatsApp configuration is complete
+        if not self.settings.has_whatsapp_config():
+            logging.warning("WhatsApp configuration incomplete. Service will be disabled.")
+            return False
 
         try:
             self.wa = WhatsApp(
-                phone_id=settings.PHONE_NUMBER_ID,
-                token=settings.ACCESS_TOKEN_LTM,
+                phone_id=self.settings.PHONE_NUMBER_ID,
+                token=self.settings.ACCESS_TOKEN_LTM,
                 server=self.app,
-                callback_url=settings.CALLBACK_URL,
-                verify_token=settings.VERIFY_TOKEN,
-                app_id=settings.APP_ID,
-                app_secret=settings.APP_SECRET,
+                callback_url=self.settings.CALLBACK_URL,
+                verify_token=self.settings.VERIFY_TOKEN,
+                app_id=self.settings.APP_ID,
+                app_secret=self.settings.APP_SECRET,
             )
+            self._register_handlers()
+            self.is_initialized = True
             logging.info("WhatsApp client initialized successfully.")
+            return True
         except Exception as e:
             logging.error(f"Failed to initialize WhatsApp client: {e}")
-            raise
-        
-        self._register_handlers()
+            logging.warning("WhatsApp service will be disabled.")
+            return False
 
     def _register_handlers(self) -> None:
         """Register message handlers."""
-        self.wa.on_message(filters.matches("Hello", "Hi", ignore_case=True))(self.handle_menu)
-        self.wa.on_message(filters.image)(self.handle_analyze)
+        if self.wa is None:
+            return
+        try:
+            self.wa.on_message(filters.matches("Hello", "Hi", ignore_case=True))(self.handle_menu)
+            self.wa.on_message(filters.image)(self.handle_analyze)
+            logging.info("WhatsApp handlers registered successfully.")
+        except Exception as e:
+            logging.error(f"Failed to register WhatsApp handlers: {e}")
+    
+    def initialize_whatsapp(self) -> bool:
+        """Public method to initialize WhatsApp service."""
+        return self._ensure_whatsapp_initialized()
 
     async def translate_text(self, text: str, dest: str) -> str:
         """Translate text to the specified language."""
@@ -93,6 +121,10 @@ async def prompt_language(self, msg: types.Message) -> str:
 
     async def handle_menu(self, _, msg: types.Message) -> None:
         """Handle greeting messages and language selection."""
+        if not self._ensure_whatsapp_initialized():
+            logging.error("WhatsApp service not available")
+            return
+            
         language = await self.prompt_language(msg)
         self.user_languages[str(msg.from_user)] = language
 
@@ -104,6 +136,11 @@ async def handle_menu(self, _, msg: types.Message) -> None:
     async def handle_analyze(self, _, msg: types.Message) -> None:
         """Handle image analysis requests."""
         try:
+            # Check if ML model is available
+            if not MODEL_AVAILABLE:
+                await msg.reply("Sorry, the disease detection service is currently unavailable.")
+                return
+            
             # Get or prompt for user language
             if str(msg.from_user) in self.user_languages:
                 language = self.user_languages[str(msg.from_user)]
@@ -120,27 +157,34 @@ async def handle_analyze(self, _, msg: types.Message) -> None:
             await msg.reply(text=process_warn)
 
             # Predict disease
-            image_disease = predict_image(original_img)
-            product = cart(image_disease)
-            
-            # Send response
-            if product is not None:
-                translated_info = await self.translate_text(
-                    return_info(image_disease), language
-                )
-                translated_product = await self.translate_text(product[0], language)
+            if MODEL_AVAILABLE and predict_image is not None:
+                image_disease = predict_image(original_img)
 
-                await msg.reply(
-                    text=translated_info,
-                    buttons=types.ButtonUrl(
-                        title=translated_product[:20], url=product[1]
-                    ),
-                )
+                if DATA_AVAILABLE and cart is not None and return_info is not None:
+                    product = cart(image_disease)
+                    
+                    # Send response
+                    if product is not None:
+                        translated_info = await self.translate_text(
+                            return_info(image_disease), language
+                        )
+                        translated_product = await self.translate_text(product[0], language)
+                        
+                        await msg.reply(
+                            text=translated_info,
+                            buttons=types.ButtonUrl(
+                                title=translated_product[:20], url=product[1]
+                            ),
+                        )
+                    else:
+                        translated_info = await self.translate_text(
+                            return_info(image_disease), language
+                        )
+                        await msg.reply(text=translated_info)
+                else:
+                    await msg.reply(f"Detected disease: {image_disease}")
             else:
-                translated_info = await self.translate_text(
-                    return_info(image_disease), language
-                )
-                await msg.reply(text=translated_info)
+                await msg.reply("Disease detection service is currently unavailable.")
 
         except Exception as e:
             logging.error(f"Error in analyze function: {e}")