Update app/main.py

app/main.py

@@ -1,81 +1,142 @@
 """
-CryptoSentinel AI — FastAPI app entry point (no /static mount)
-- Fetches live prices from CoinGecko
-- Provides real-time sentiment analysis via SSE
-- Compatible with Hugging Face Spaces
-"""
+CryptoSentinel AI — High-performance FastAPI application.
 
-import json
+Features:
+- Fully asynchronous architecture using modern FastAPI lifespan and background tasks.
+- Integrates a robust, async PriceFetcher with multi-API fallback.
+- Provides real-time sentiment analysis via an efficient, non-polling SSE stream.
+- Centralized state management for testability and clarity.
+"""
 import asyncio
-from pathlib import Path
+import json
+from contextlib import asynccontextmanager
 
+import httpx
 from fastapi import FastAPI, Request, BackgroundTasks
-from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse
+from fastapi.responses import HTMLResponse, StreamingResponse
 from fastapi.templating import Jinja2Templates
-from apscheduler.schedulers.background import BackgroundScheduler
+from pydantic import BaseModel, constr
+
+from .price_fetcher import PriceFetcher
+from .sentiment import SentimentAnalyzer
+
+# --- Configuration & Models ---
+
+class SentimentRequest(BaseModel):
+    """Pydantic model for validating sentiment analysis requests."""
+    text: constr(strip_whitespace=True, min_length=1)
 
-from price_fetcher import fetch_prices, CURRENT_PRICES
-from sentiment import SentimentCache
+# --- Application Lifespan Management ---
 
-# ────── Setup ───────────────────────────────────────────────────────────────
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """
+    Manages application startup and shutdown events. This is the modern
+    replacement for @app.on_event("startup") and "shutdown".
+    """
+    # -- Startup --
+    # Create a single, shared httpx client for the application's lifespan.
+    async with httpx.AsyncClient() as client:
+        # Initialize our stateful services
+        price_fetcher = PriceFetcher(client=client, coins=["bitcoin", "ethereum", "dogecoin"])
+        sentiment_analyzer = SentimentAnalyzer()
 
-BASE_DIR = Path(__file__).parent
-templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
+        # Store service instances in the app's state for access in routes
+        app.state.price_fetcher = price_fetcher
+        app.state.sentiment_analyzer = sentiment_analyzer
+        app.state.request_counter = 0
 
-app = FastAPI(title="CryptoSentinel AI (CDN-only static)")
+        # Create a cancellable background task for periodic price updates
+        price_update_task = asyncio.create_task(
+            run_periodic_updates(price_fetcher, interval_seconds=10)
+        )
+        
+        print("🚀 CryptoSentinel AI started successfully.")
+        yield  # The application is now running
+        
+        # -- Shutdown --
+        print("⏳ Shutting down background tasks...")
+        price_update_task.cancel()
+        try:
+            await price_update_task
+        except asyncio.CancelledError:
+            print("Price update task cancelled successfully.")
+        print("✅ Shutdown complete.")
 
-# Start background job to refresh prices every 10s
-scheduler = BackgroundScheduler(daemon=True)
-scheduler.add_job(fetch_prices, trigger="interval", seconds=10)
-scheduler.start()
+async def run_periodic_updates(fetcher: PriceFetcher, interval_seconds: int):
+    """A simple, robust asyncio background task runner."""
+    while True:
+        await fetcher.update_prices_async()
+        await asyncio.sleep(interval_seconds)
 
-@app.on_event("shutdown")
-def shutdown():
-    scheduler.shutdown(wait=False)
+# --- FastAPI App Initialization ---
 
-@app.on_event("startup")
-def warmup_model():
-    # Preload the sentiment model once on startup
-    SentimentCache.compute("The market is pumping 🚀")
+templates = Jinja2Templates(directory="app/templates")
+app = FastAPI(title="CryptoSentinel AI", lifespan=lifespan)
 
-# ────── Routes ──────────────────────────────────────────────────────────────
+# --- Routes ---
 
 @app.get("/", response_class=HTMLResponse)
 async def index(request: Request):
+    """Renders the main single-page application view."""
+    return templates.TemplateResponse("index.html", {"request": request})
+
+@app.get("/api/prices", response_class=HTMLResponse)
+async def get_prices_fragment(request: Request):
     """
-    Renders index.html which now should reference HTMX via CDN:
-      <script src="https://unpkg.com/[email protected]"></script>
+    Returns an HTML fragment with the latest crypto prices.
+    Designed to be called by HTMX.
     """
-    return templates.TemplateResponse("index.html", {"request": request})
+    price_fetcher: PriceFetcher = request.app.state.price_fetcher
+    prices = price_fetcher.get_current_prices()
 
-@app.get("/prices", response_class=JSONResponse)
-async def prices():
-    """Return the latest cached crypto prices."""
-    return CURRENT_PRICES
+    html_fragment = ""
+    for coin, price in prices.items():
+        price_str = f"${price:,.2f}" if isinstance(price, (int, float)) else price
+        html_fragment += f"<div><strong>{coin.capitalize()}:</strong> {price_str}</div>"
+    
+    return HTMLResponse(content=html_fragment)
 
-@app.post("/sentiment")
-async def sentiment(request: Request, background_tasks: BackgroundTasks):
+@app.post("/api/sentiment")
+async def analyze_sentiment(
+    payload: SentimentRequest,
+    request: Request,
+    background_tasks: BackgroundTasks
+):
     """
-    Queue sentiment analysis for the given text.
-    Frontend will pick up results via SSE.
+    Accepts text for sentiment analysis, validates it, and queues it
+    for processing in the background.
     """
-    body = await request.json()
-    background_tasks.add_task(SentimentCache.compute, body.get("text", ""))
-    return {"status": "queued"}
+    analyzer: SentimentAnalyzer = request.app.state.sentiment_analyzer
+    
+    # Use a simple counter for unique event IDs
+    request.app.state.request_counter += 1
+    request_id = request.app.state.request_counter
+
+    # Add the heavy computation to the background so the API returns instantly
+    background_tasks.add_task(analyzer.compute_and_publish, payload.text, request_id)
+    
+    return {"status": "queued", "request_id": request_id}
 
-@app.get("/sentiment/stream")
-async def sentiment_stream():
+@app.get("/api/sentiment/stream")
+async def sentiment_stream(request: Request):
     """
-    Server-Sent Events endpoint that pushes new sentiment results
-    as they become available in SentimentCache.latest_result.
+    Server-Sent Events (SSE) endpoint.
+    This long-lived connection efficiently waits for new sentiment results
+    from the queue and pushes them to the client.
     """
+    analyzer: SentimentAnalyzer = request.app.state.sentiment_analyzer
+
     async def event_generator():
-        last_id = 0
         while True:
-            if SentimentCache.latest_id != last_id:
-                last_id = SentimentCache.latest_id
-                payload = json.dumps(SentimentCache.latest_result)
-                yield f"id:{last_id}\ndata:{payload}\n\n"
-            await asyncio.sleep(1)
+            try:
+                # This is the key: efficiently wait for a result to be put in the queue
+                result_payload = await analyzer.get_next_result()
+                payload_str = json.dumps(result_payload)
+                yield f"id:{result_payload['id']}\nevent: sentiment_update\ndata:{payload_str}\n\n"
+            except asyncio.CancelledError:
+                # Handle client disconnect
+                print("Client disconnected from SSE stream.")
+                break
 
-    return StreamingResponse(event_generator(), media_type="text/event-stream")
+    return StreamingResponse(event_generator(), media_type="text/event-stream")