Update app.py

app.py

@@ -2,11 +2,12 @@ import asyncio
 import os
 from datetime import datetime
 from typing import Dict, List, Optional
-from fastapi.responses import JSONResponse, HTMLResponse
+
 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
@@ -20,9 +21,6 @@ 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",
@@ -46,10 +44,14 @@ analysis_service = AnalysisService()
 # In-memory store for latest analysis
 latest_analysis: Optional[ConflictAnalysis] = None
 last_update_time: Optional[datetime] = None
-background_task = None  # Store task reference to cancel if needed
 
-# Feature flags
-AUTO_UPDATE_ENABLED = os.getenv("AUTO_UPDATE_ENABLED", "false").lower() in ("true", "1", "t")
+# 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:
@@ -65,51 +67,45 @@ async def get_analysis_service() -> AnalysisService:
 @app.on_event("startup")
 async def startup_event():
     """Initialize services on startup."""
-    
     logger.info("Starting up WesternFront API")
     
-    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
-
-        logger.info("Application ready to accept requests")
-        
-        # Only start background tasks if auto-update is enabled
-        if AUTO_UPDATE_ENABLED:
-            logger.info("Auto-update enabled. Starting background tasks.")
-            # Use scheduled_update_task to avoid continuous execution
-            asyncio.create_task(scheduled_update_task())
-        else:
-            logger.info("Auto-update disabled. Background analysis will not run automatically.")
-        
-    except Exception as e:
-        logger.error(f"Error during startup: {e}")
+    # 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)}")
+    
+    # Schedule first update
+    background_tasks = BackgroundTasks()
+    background_tasks.add_task(update_analysis_task)
+    
+    # Set up periodic update task
+    asyncio.create_task(periodic_update())
 
 
 @app.on_event("shutdown")
 async def shutdown_event():
     """Clean up resources on shutdown."""
-    global background_task
-    
     logger.info("Shutting down WesternFront API")
-    
-    # Cancel any running background tasks
-    if background_task and not background_task.done():
-        logger.info("Cancelling running background task")
-        background_task.cancel()
-        try:
-            await background_task
-        except asyncio.CancelledError:
-            pass
-    
     if twitter_service and hasattr(twitter_service, 'close'):
         await twitter_service.close()
     if analysis_service and hasattr(analysis_service, 'close'):
@@ -147,68 +143,29 @@ async def update_analysis_task(trigger: str = "scheduled") -> None:
         logger.error(f"Error in update_analysis_task: {str(e)}")
 
 
-async def scheduled_update_task() -> None:
-    """Run a single scheduled update then exit."""
-    global background_task
+async def periodic_update() -> None:
+    """Periodically update the analysis."""
+    update_interval = int(os.getenv("UPDATE_INTERVAL_MINUTES", 60))
     
-    try:
-        # Wait a few seconds after startup before first update
-        await asyncio.sleep(10)
-        background_task = asyncio.create_task(update_analysis_task("startup"))
-        await background_task
-    except Exception as e:
-        logger.error(f"Error in scheduled_update_task: {str(e)}")
+    while True:
+        try:
+            await asyncio.sleep(update_interval * 60)  # Convert to seconds
+            await update_analysis_task("scheduled")
+        except Exception as e:
+            logger.error(f"Error in periodic_update: {str(e)}")
+            await asyncio.sleep(300)  # Wait 5 minutes if there was an error
 
-app_ready = True  # Force this to True for Hugging Face Spaces
 
-# Update the root endpoint to be Hugging Face Spaces friendly
-@app.get("/", response_class=HTMLResponse)
-async def root():
-    """Root endpoint designed for Hugging Face Spaces."""
-    html_content = """
-    <!DOCTYPE html>
-    <html>
-        <head>
-            <title>WesternFront API</title>
-            <meta property="og:title" content="WesternFront API">
-            <meta property="og:description" content="AI-powered conflict tracker for India-Pakistan tensions">
-        </head>
-        <body>
-            <h1>WesternFront API</h1>
-            <p>API is running successfully! Access the API documentation at <a href="/docs">/docs</a></p>
-            <p>Version: 1.1.0</p>
-            <p>Status: Ready</p>
-        </body>
-    </html>
-    """
-    return HTMLResponse(content=html_content)
-
-# Add a Hugging Face Spaces specific health check endpoint
-@app.get("/health-check")
-async def hf_health_check():
-    """Health check endpoint specifically for Hugging Face Spaces."""
-    return JSONResponse(status_code=200, content={"status": "healthy"})
-    
 @app.get("/", response_model=Dict)
 async def root():
     """Root endpoint with basic information about the API."""
     return {
         "name": "WesternFront API",
         "description": "AI-powered conflict tracker for India-Pakistan tensions",
-        "version": "1.1.0",
-        "status": "ready" if app_ready else "initializing",
-        "auto_update": AUTO_UPDATE_ENABLED
+        "version": "1.1.0"
     }
 
 
-@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."""
@@ -216,14 +173,13 @@ async def health_check():
     gemini_initialized = analysis_service.model is not None
     
     return HealthCheck(
-        status="healthy" if app_ready else "initializing",
+        status="healthy",
         version="1.1.0",
         timestamp=datetime.now(),
         last_update=last_update_time,
         components_status={
             "twitter_service": twitter_initialized,
-            "analysis_service": gemini_initialized,
-            "auto_update": AUTO_UPDATE_ENABLED
+            "analysis_service": gemini_initialized
         }
     )
 
@@ -241,20 +197,20 @@ async def get_latest_analysis():
 
 @app.post("/analysis/update", response_model=Dict)
 async def trigger_update(
-    request: UpdateRequest, 
+    request: UpdateRequest,
     background_tasks: BackgroundTasks
 ):
     """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")
     
     return {
         "message": "Analysis update triggered",
-        "timestamp": datetime.now().isoformat(),
+        "timestamp": datetime.now(),
         "force_refresh": request.force
     }
 
@@ -307,6 +263,32 @@ 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)