Update app.py

app.py

@@ -1,248 +1,248 @@
-import asyncio
-import os
-from datetime import datetime
-from typing import Dict, List, Optional
-
-from dotenv import load_dotenv
-from fastapi import BackgroundTasks, Depends, FastAPI, HTTPException, status
-from fastapi.middleware.cors import CORSMiddleware
-from loguru import logger
-
-# --- UPDATED IMPORTS ---
-from analysis_service import AnalysisService
-# No longer need RssTwitterService
-from models import (ConflictAnalysis, HealthCheck, SubredditSource, TensionLevel,
-                    UpdateRequest)
-
-# Load environment variables from .env file
-load_dotenv()
-
-# Configure logging
-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",
-    description="AI-powered conflict tracker for monitoring India-Pakistan tensions using Reddit data",
-    version="2.0.0" # Version bump for new data source
-)
-
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # Adjust this for production
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# --- UPDATED: Services ---
-# The AnalysisService now manages the RedditService internally
-analysis_service = AnalysisService()
-
-# In-memory store for latest analysis
-latest_analysis: Optional[ConflictAnalysis] = None
-last_update_time: Optional[datetime] = None
-
-
-async def get_analysis_service() -> AnalysisService:
-    """Dependency to get the Analysis service."""
-    return analysis_service
-
-
-@app.on_event("startup")
-async def startup_event():
-    """Initialize services on startup."""
-    global app_ready
-    
-    logger.info("Starting up WesternFront API v2.0")
-    
-    try:
-        # Initialize Gemini AI and the internal Reddit service
-        analysis_service.initialize_gemini()
-        analysis_service.reddit_service.initialize()
-        
-        # 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
-
-
-@app.on_event("shutdown")
-async def shutdown_event():
-    """Clean up resources on shutdown."""
-    logger.info("Shutting down WesternFront API")
-    if analysis_service and hasattr(analysis_service, 'close'):
-        await analysis_service.close()
-
-
-async def update_analysis_task(trigger: str = "scheduled") -> None:
-    """Task to update the conflict analysis using the AnalysisService."""
-    global latest_analysis, last_update_time
-    
-    try:
-        logger.info(f"Starting analysis update (trigger: {trigger})")
-        
-        # --- REFACTORED: The analysis_service now handles everything ---
-        analysis = await analysis_service.generate_conflict_analysis(trigger=trigger)
-        
-        if analysis:
-            latest_analysis = analysis
-            last_update_time = datetime.now()
-            logger.info(f"Analysis updated successfully. Tension level: {analysis.tension_level}")
-        else:
-            logger.warning("Failed to generate new analysis. No relevant data might be available.")
-            
-    except Exception as e:
-        logger.error(f"Error in update_analysis_task: {str(e)}")
-
-
-async def periodic_update() -> None:
-    """Periodically update the analysis."""
-    update_interval = int(os.getenv("UPDATE_INTERVAL_MINUTES", 60))
-    
-    while True:
-        try:
-            await asyncio.sleep(update_interval * 60)
-            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.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 using Reddit data",
-        "version": "2.0.0",
-        "status": "ready" if app_ready else "initializing"
-    }
-
-
-@app.get("/ready")
-async def readiness_check():
-    """Readiness check endpoint."""
-    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."""
-    # --- UPDATED: Check Reddit service instead of Twitter ---
-    reddit_initialized = analysis_service.reddit_service.reddit is not None
-    gemini_initialized = analysis_service.model is not None
-    
-    return HealthCheck(
-        status="healthy" if app_ready else "initializing",
-        version="2.0.0",
-        timestamp=datetime.now(),
-        last_update=last_update_time,
-        components_status={
-            "reddit_service": reddit_initialized,
-            "analysis_service": gemini_initialized
-        }
-    )
-
-# The HEAD /health endpoint is a bit redundant with FastAPI, so it can be removed for simplicity
-# unless you have a specific use case for it.
-
-@app.get("/analysis", response_model=Optional[ConflictAnalysis])
-async def get_latest_analysis():
-    """Get the latest conflict analysis."""
-    if not latest_analysis:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="No analysis available yet. Try triggering an update."
-        )
-    return latest_analysis
-
-
-@app.post("/analysis/update", response_model=Dict)
-async def trigger_update(request: UpdateRequest):
-    """Trigger an analysis update."""
-    if request.force:
-        # --- UPDATED: Clear Reddit service cache ---
-        analysis_service.reddit_service.in_memory_cache.clear()
-        logger.info("Cache cleared for forced refresh.")
-    
-    # Start update in background
-    asyncio.create_task(update_analysis_task("manual"))
-    
-    return {
-        "message": "Analysis update triggered",
-        "timestamp": datetime.now().isoformat(),
-        "force_refresh": request.force
-    }
-
-
-# --- UPDATED: Now manages subreddit sources ---
-@app.get("/sources", response_model=List[SubredditSource])
-async def get_subreddit_sources(
-    analysis: AnalysisService = Depends(get_analysis_service)
-):
-    """Get the current list of subreddit sources."""
-    return analysis.get_sources()
-
-
-# --- UPDATED: Now manages subreddit sources ---
-@app.post("/sources", response_model=Dict)
-async def update_subreddit_sources(
-    sources: List[SubredditSource],
-    analysis: AnalysisService = Depends(get_analysis_service)
-):
-    """Update the list of subreddit sources."""
-    analysis.update_sources(sources)
-    return {
-        "message": "Subreddit sources updated",
-        "count": len(sources)
-    }
-
-
-@app.get("/keywords", response_model=List[str])
-async def get_search_keywords(
-    analysis: AnalysisService = Depends(get_analysis_service)
-):
-    """Get the current search keywords."""
-    return analysis.get_search_keywords()
-
-
-@app.post("/keywords", response_model=Dict)
-async def update_search_keywords(
-    keywords: List[str],
-    analysis: AnalysisService = Depends(get_analysis_service)
-):
-    """Update the search keywords."""
-    analysis.update_search_keywords(keywords)
-    return {
-        "message": "Search keywords updated",
-        "count": len(keywords)
-    }
-
-
-@app.get("/tension-levels", response_model=List[str])
-async def get_tension_levels():
-    """Get the available tension levels."""
-    return [level.value for level in TensionLevel]
-
-# --- REMOVED: /rss-feeds endpoint is no longer applicable ---
-
-if __name__ == "__main__":
-    import uvicorn
+import asyncio
+import os
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from dotenv import load_dotenv
+from fastapi import BackgroundTasks, Depends, FastAPI, HTTPException, status
+from fastapi.middleware.cors import CORSMiddleware
+from loguru import logger
+
+# --- UPDATED IMPORTS ---
+from analysis_service import AnalysisService
+# No longer need RssTwitterService
+from models import (ConflictAnalysis, HealthCheck, SubredditSource, TensionLevel,
+                    UpdateRequest)
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Configure logging
+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",
+    description="AI-powered conflict tracker for monitoring India-Pakistan tensions using Reddit data",
+    version="2.0.0" # Version bump for new data source
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Adjust this for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# --- UPDATED: Services ---
+# The AnalysisService now manages the RedditService internally
+analysis_service = AnalysisService()
+
+# In-memory store for latest analysis
+latest_analysis: Optional[ConflictAnalysis] = None
+last_update_time: Optional[datetime] = None
+
+
+async def get_analysis_service() -> AnalysisService:
+    """Dependency to get the Analysis service."""
+    return analysis_service
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize services on startup."""
+    global app_ready
+    
+    logger.info("Starting up WesternFront API v2.0")
+    
+    try:
+        # Initialize Gemini AI and the internal Reddit service
+        analysis_service.initialize_gemini()
+        analysis_service.reddit_service.initialize()
+        
+        # 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
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Clean up resources on shutdown."""
+    logger.info("Shutting down WesternFront API")
+    if analysis_service and hasattr(analysis_service, 'close'):
+        await analysis_service.close()
+
+
+async def update_analysis_task(trigger: str = "scheduled") -> None:
+    """Task to update the conflict analysis using the AnalysisService."""
+    global latest_analysis, last_update_time
+    
+    try:
+        logger.info(f"Starting analysis update (trigger: {trigger})")
+        
+        # --- REFACTORED: The analysis_service now handles everything ---
+        analysis = await analysis_service.generate_conflict_analysis(trigger=trigger)
+        
+        if analysis:
+            latest_analysis = analysis
+            last_update_time = datetime.now()
+            logger.info(f"Analysis updated successfully. Tension level: {analysis.tension_level}")
+        else:
+            logger.warning("Failed to generate new analysis. No relevant data might be available.")
+            
+    except Exception as e:
+        logger.error(f"Error in update_analysis_task: {str(e)}")
+
+
+async def periodic_update() -> None:
+    """Periodically update the analysis."""
+    update_interval = int(os.getenv("UPDATE_INTERVAL_MINUTES", 60))
+    
+    while True:
+        try:
+            await asyncio.sleep(update_interval * 60)
+            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.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 using Reddit data",
+        "version": "2.0.0",
+        "status": "ready" if app_ready else "initializing"
+    }
+
+
+@app.get("/ready")
+async def readiness_check():
+    """Readiness check endpoint."""
+    if not app_ready:
+        raise HTTPException(status_code=503, detail="Application is starting up")
+    return {"status": "ready", "timestamp": datetime.now().isoformat()}
+
+@app.head("/health", response_model=HealthCheck)
+@app.get("/health", response_model=HealthCheck)
+async def health_check():
+    """Health check endpoint."""
+    # --- UPDATED: Check Reddit service instead of Twitter ---
+    reddit_initialized = analysis_service.reddit_service.reddit is not None
+    gemini_initialized = analysis_service.model is not None
+    
+    return HealthCheck(
+        status="healthy" if app_ready else "initializing",
+        version="2.0.0",
+        timestamp=datetime.now(),
+        last_update=last_update_time,
+        components_status={
+            "reddit_service": reddit_initialized,
+            "analysis_service": gemini_initialized
+        }
+    )
+
+# The HEAD /health endpoint is a bit redundant with FastAPI, so it can be removed for simplicity
+# unless you have a specific use case for it.
+
+@app.get("/analysis", response_model=Optional[ConflictAnalysis])
+async def get_latest_analysis():
+    """Get the latest conflict analysis."""
+    if not latest_analysis:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="No analysis available yet. Try triggering an update."
+        )
+    return latest_analysis
+
+
+@app.post("/analysis/update", response_model=Dict)
+async def trigger_update(request: UpdateRequest):
+    """Trigger an analysis update."""
+    if request.force:
+        # --- UPDATED: Clear Reddit service cache ---
+        analysis_service.reddit_service.in_memory_cache.clear()
+        logger.info("Cache cleared for forced refresh.")
+    
+    # Start update in background
+    asyncio.create_task(update_analysis_task("manual"))
+    
+    return {
+        "message": "Analysis update triggered",
+        "timestamp": datetime.now().isoformat(),
+        "force_refresh": request.force
+    }
+
+
+# --- UPDATED: Now manages subreddit sources ---
+@app.get("/sources", response_model=List[SubredditSource])
+async def get_subreddit_sources(
+    analysis: AnalysisService = Depends(get_analysis_service)
+):
+    """Get the current list of subreddit sources."""
+    return analysis.get_sources()
+
+
+# --- UPDATED: Now manages subreddit sources ---
+@app.post("/sources", response_model=Dict)
+async def update_subreddit_sources(
+    sources: List[SubredditSource],
+    analysis: AnalysisService = Depends(get_analysis_service)
+):
+    """Update the list of subreddit sources."""
+    analysis.update_sources(sources)
+    return {
+        "message": "Subreddit sources updated",
+        "count": len(sources)
+    }
+
+
+@app.get("/keywords", response_model=List[str])
+async def get_search_keywords(
+    analysis: AnalysisService = Depends(get_analysis_service)
+):
+    """Get the current search keywords."""
+    return analysis.get_search_keywords()
+
+
+@app.post("/keywords", response_model=Dict)
+async def update_search_keywords(
+    keywords: List[str],
+    analysis: AnalysisService = Depends(get_analysis_service)
+):
+    """Update the search keywords."""
+    analysis.update_search_keywords(keywords)
+    return {
+        "message": "Search keywords updated",
+        "count": len(keywords)
+    }
+
+
+@app.get("/tension-levels", response_model=List[str])
+async def get_tension_levels():
+    """Get the available tension levels."""
+    return [level.value for level in TensionLevel]
+
+# --- REMOVED: /rss-feeds endpoint is no longer applicable ---
+
+if __name__ == "__main__":
+    import uvicorn
     uvicorn.run("app:app", host="0.0.0.0", port=8000, reload=True)