Update app.py

app.py

@@ -7,7 +7,6 @@ from dotenv import load_dotenv
 from fastapi import BackgroundTasks, Depends, FastAPI, HTTPException, status
 from fastapi.middleware.cors import CORSMiddleware
 from loguru import logger
-from pydantic import BaseModel
 
 from analysis_service import AnalysisService
 from twitter_service import RssTwitterService
@@ -21,6 +20,9 @@ load_dotenv()
 os.makedirs("logs", exist_ok=True)
 logger.add("logs/app.log", rotation="500 MB", level=os.getenv("LOG_LEVEL", "INFO"))
 
+# Global readiness flag 
+app_ready = False
+
 # Create FastAPI application
 app = FastAPI(
     title="WesternFront API",
@@ -45,14 +47,6 @@ analysis_service = AnalysisService()
 latest_analysis: Optional[ConflictAnalysis] = None
 last_update_time: Optional[datetime] = None
 
-# Define model for RSS feed registration
-class RssFeedRegistration(BaseModel):
-    twitter_handle: str
-    rss_url: str
-
-class RssFeedBatch(BaseModel):
-    feeds: Dict[str, str]
-
 
 async def get_twitter_service() -> RssTwitterService:
     """Dependency to get the Twitter service."""
@@ -67,39 +61,35 @@ async def get_analysis_service() -> AnalysisService:
 @app.on_event("startup")
 async def startup_event():
     """Initialize services on startup."""
-    logger.info("Starting up WesternFront API")
-    
-    # Initialize services
-    twitter_initialized = await twitter_service.initialize()
-    if not twitter_initialized:
-        logger.warning("Twitter service initialization failed. Some features may not work.")
-    
-    # Set analysis service's twitter service reference
-    analysis_service.twitter_service = twitter_service
-    
-    # Initialize Gemini AI service
-    gemini_initialized = analysis_service.initialize()
-    if not gemini_initialized:
-        logger.warning("Gemini AI initialization failed. Analysis features may not work.")
-    
-    # Load RSS feeds from environment variable if available
-    rss_feeds_env = os.getenv("RSS_FEEDS")
-    if rss_feeds_env:
-        try:
-            import json
-            feeds = json.loads(rss_feeds_env)
-            if isinstance(feeds, dict):
-                twitter_service.register_rss_feed_batch(feeds)
-                logger.info(f"Loaded {len(feeds)} RSS feeds from environment variables")
-        except Exception as e:
-            logger.error(f"Failed to load RSS feeds from environment variables: {str(e)}")
+    global app_ready
     
-    # Schedule first update
-    background_tasks = BackgroundTasks()
-    background_tasks.add_task(update_analysis_task)
+    logger.info("Starting up WesternFront API")
     
-    # Set up periodic update task
-    asyncio.create_task(periodic_update())
+    try:
+        # Initialize Twitter service
+        twitter_initialized = await twitter_service.initialize()
+        if not twitter_initialized:
+            logger.warning("Twitter service initialization failed. Some features may not work.")
+        
+        # Initialize Gemini AI service
+        analysis_service.initialize()
+        
+        # Set analysis service's twitter service reference
+        analysis_service.twitter_service = twitter_service
+        
+        # Schedule first update in background
+        asyncio.create_task(update_analysis_task("startup"))
+        
+        # Set up periodic update task
+        asyncio.create_task(periodic_update())
+        
+        # Mark application as ready to accept requests
+        app_ready = True
+        logger.info("Application ready to accept requests")
+        
+    except Exception as e:
+        logger.error(f"Error during startup: {e}")
+        app_ready = False  # Keep app in not-ready state if startup fails
 
 
 @app.on_event("shutdown")
@@ -162,10 +152,19 @@ async def root():
     return {
         "name": "WesternFront API",
         "description": "AI-powered conflict tracker for India-Pakistan tensions",
-        "version": "1.1.0"
+        "version": "1.1.0",
+        "status": "ready" if app_ready else "initializing"
     }
 
 
+@app.get("/ready")
+async def readiness_check():
+    """Readiness check endpoint for probes and monitoring."""
+    if not app_ready:
+        raise HTTPException(status_code=503, detail="Application is starting up")
+    return {"status": "ready", "timestamp": datetime.now().isoformat()}
+
+
 @app.get("/health", response_model=HealthCheck)
 async def health_check():
     """Health check endpoint."""
@@ -173,7 +172,7 @@ async def health_check():
     gemini_initialized = analysis_service.model is not None
     
     return HealthCheck(
-        status="healthy",
+        status="healthy" if app_ready else "initializing",
         version="1.1.0",
         timestamp=datetime.now(),
         last_update=last_update_time,
@@ -196,21 +195,18 @@ async def get_latest_analysis():
 
 
 @app.post("/analysis/update", response_model=Dict)
-async def trigger_update(
-    request: UpdateRequest,
-    background_tasks: BackgroundTasks
-):
+async def trigger_update(request: UpdateRequest):
     """Trigger an analysis update."""
     if request.force:
         # Clear cache to force fresh tweets
         twitter_service.in_memory_cache.clear()
-        
-    # Add update task to background tasks
-    background_tasks.add_task(update_analysis_task, "manual")
+    
+    # Start update in background
+    asyncio.create_task(update_analysis_task("manual"))
     
     return {
         "message": "Analysis update triggered",
-        "timestamp": datetime.now(),
+        "timestamp": datetime.now().isoformat(),
         "force_refresh": request.force
     }
 
@@ -263,32 +259,6 @@ async def get_tension_levels():
     return [level.value for level in TensionLevel]
 
 
-@app.post("/rss-feed", response_model=Dict)
-async def register_rss_feed(
-    feed: RssFeedRegistration,
-    twitter: RssTwitterService = Depends(get_twitter_service)
-):
-    """Register an RSS feed for a Twitter handle."""
-    twitter.register_rss_feed(feed.twitter_handle, feed.rss_url)
-    return {
-        "message": f"RSS feed registered for {feed.twitter_handle}",
-        "twitter_handle": feed.twitter_handle
-    }
-
-
-@app.post("/rss-feeds", response_model=Dict)
-async def register_rss_feeds(
-    feeds: RssFeedBatch,
-    twitter: RssTwitterService = Depends(get_twitter_service)
-):
-    """Register multiple RSS feeds at once."""
-    twitter.register_rss_feed_batch(feeds.feeds)
-    return {
-        "message": "RSS feeds registered",
-        "count": len(feeds.feeds)
-    }
-
-
 @app.get("/rss-feeds", response_model=Dict[str, str])
 async def get_registered_rss_feeds(
     twitter: RssTwitterService = Depends(get_twitter_service)