Update app.py

app.py

@@ -1,111 +1,156 @@
+"""
+CryptoSentinel AI — High-performance FastAPI application.
+
+This is the main entry point that orchestrates the entire application.
+- Integrates the asynchronous PriceFetcher for live market data.
+- Integrates the asynchronous SentimentAnalyzer for real-time analysis.
+- Serves the interactive frontend and provides all necessary API endpoints.
+"""
+import asyncio
+import json
+from contextlib import asynccontextmanager
+
 import httpx
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.responses import HTMLResponse
+from fastapi import FastAPI, Request, BackgroundTasks
+from fastapi.responses import HTMLResponse, StreamingResponse
 from fastapi.templating import Jinja2Templates
-from pydantic import BaseModel, ValidationError
-from contextlib import asynccontextmanager
+from pydantic import BaseModel, constr
 
-# --- Configuration ---
-# Centralized configuration makes the app easier to modify.
-COINGECKO_API_URL = "https://api.coingecko.com/api/v3/simple/price"
-TARGET_COINS = ["bitcoin", "ethereum", "dogecoin"]
-TARGET_CURRENCY = "usd"
+# Import our modular, asynchronous service classes
+from app.price_fetcher import PriceFetcher
+from app.sentiment import SentimentAnalyzer
 
-# --- Pydantic Models for Data Validation ---
-# This ensures the API response from CoinGecko matches our expectations.
-class PriceData(BaseModel):
-    usd: float
+# --- Pydantic Model for API Input Validation ---
 
-# The full response is a dictionary mapping coin names (str) to their PriceData.
-# Example: {"bitcoin": {"usd": 65000.0}}
-ApiResponse = dict[str, PriceData]
+class SentimentRequest(BaseModel):
+    """Ensures the text for sentiment analysis is a non-empty string."""
+    text: constr(strip_whitespace=True, min_length=1)
 
-# --- Application State and Lifespan Management ---
-# Using a lifespan event is the modern way to manage resources like HTTP clients.
-# This client will be created on startup and closed gracefully on shutdown.
-app_state = {}
+# --- Application Lifespan for Resource Management ---
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    # On startup: create a single, reusable httpx client.
-    app_state["http_client"] = httpx.AsyncClient()
-    yield
-    # On shutdown: close the client.
-    await app_state["http_client"].aclose()
+    """
+    Manages application startup and shutdown events using the modern
+    lifespan context manager.
+    """
+    # On startup:
+    async with httpx.AsyncClient() as client:
+        # Instantiate and store our services in the application state.
+        # This makes them accessible in any request handler via `request.app.state`.
+        app.state.price_fetcher = PriceFetcher(client=client, coins=["bitcoin", "ethereum", "dogecoin"])
+        app.state.sentiment_analyzer = SentimentAnalyzer(client=client)
+        app.state.request_counter = 0  # Simple counter for unique SSE event IDs
+
+        # Create a cancellable background task for continuous price updates.
+        price_update_task = asyncio.create_task(
+            run_periodic_updates(app.state.price_fetcher, interval_seconds=10)
+        )
+        
+        print("🚀 CryptoSentinel AI started successfully.")
+        yield  # The application is now running and ready to accept requests.
+        
+        # On 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.")
+
+async def run_periodic_updates(fetcher: PriceFetcher, interval_seconds: int):
+    """A robust asyncio background task that periodically updates prices."""
+    while True:
+        await fetcher.update_prices_async()
+        await asyncio.sleep(interval_seconds)
 
 # --- FastAPI App Initialization ---
-app = FastAPI(lifespan=lifespan)
-templates = Jinja2Templates(directory="templates")
 
+app = FastAPI(title="CryptoSentinel AI", lifespan=lifespan)
+templates = Jinja2Templates(directory="app/templates")
 
 # --- API Endpoints ---
 
 @app.get("/", response_class=HTMLResponse)
-async def serve_home_page(request: Request):
-    """Serves the main HTML page which will then trigger HTMX calls."""
+async def serve_dashboard(request: Request):
+    """Serves the main interactive dashboard from `index.html`."""
     return templates.TemplateResponse("index.html", {"request": request})
 
 @app.get("/api/prices", response_class=HTMLResponse)
-async def get_prices_ui():
+async def get_prices_fragment(request: Request):
+    """Returns an HTML fragment with the latest cached crypto prices for HTMX."""
+    price_fetcher: PriceFetcher = request.app.state.price_fetcher
+    prices = price_fetcher.get_current_prices()
+
+    html_fragment = ""
+    for coin, price in prices.items():
+        # Format the price nicely, handling the initial '--' state
+        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("/api/sentiment")
+async def analyze_sentiment(
+    payload: SentimentRequest,
+    request: Request,
+    background_tasks: BackgroundTasks
+):
     """
-    This endpoint is called by HTMX.
-    It fetches crypto data and returns an HTML FRAGMENT to be swapped into the page.
+    Validates and queues a text for sentiment analysis. The heavy lifting is
+    done in the background to ensure the API responds instantly.
     """
-    try:
-        client: httpx.AsyncClient = app_state["http_client"]
-        
-        # Build the request parameters dynamically
-        params = {
-            "ids": ",".join(TARGET_COINS),
-            "vs_currencies": TARGET_CURRENCY
-        }
-        
-        response = await client.get(COINGECKO_API_URL, params=params)
-        response.raise_for_status()  # Raise an exception for 4xx/5xx errors
+    analyzer: SentimentAnalyzer = request.app.state.sentiment_analyzer
+    request.app.state.request_counter += 1
+    request_id = request.app.state.request_counter
 
-        # Validate the received data against our Pydantic model
-        prices = ApiResponse(**response.json())
-
-        # This is a simple but effective way to render an HTML fragment.
-        # For larger fragments, you would use another Jinja2 template.
-        html_fragment = ""
-        for coin, data in prices.items():
-            html_fragment += f"<div><strong>{coin.capitalize()}:</strong> ${data.usd:,.2f}</div>"
-        
-        return HTMLResponse(content=html_fragment)
+    # The actual API call to Hugging Face will run after this response is sent.
+    background_tasks.add_task(analyzer.compute_and_publish, payload.text, request_id)
+    
+    return HTMLResponse(content="<small>Queued for analysis...</small>")
 
-    except httpx.RequestError as e:
-        # Handle network-related errors
-        return HTMLResponse(content=f"<div class='error'>Network error: Could not connect to CoinGecko.</div>", status_code=503)
-    except ValidationError as e:
-        # Handle cases where CoinGecko's API response changes unexpectedly
-        return HTMLResponse(content=f"<div class='error'>Invalid API response from data source.</div>", status_code=502)
-    except Exception as e:
-        # Generic catch-all for other unexpected errors
-        return HTMLResponse(content=f"<div class='error'>An unexpected error occurred.</div>", status_code=500)
-
-
-@app.get("/api/forecast/{coin_id}")
-async def get_forecast(coin_id: str):
+@app.get("/api/sentiment/stream")
+async def sentiment_stream(request: Request):
     """
-    Placeholder for a real forecasting model.
-    A real implementation would involve loading a pre-trained model,
-    fetching historical data, and running a prediction.
+    Establishes a Server-Sent Events (SSE) connection. It efficiently pushes
+    new sentiment results as HTML fragments to the client as they become available.
     """
-    if coin_id not in TARGET_COINS:
-        raise HTTPException(status_code=404, detail=f"Forecast not available for '{coin_id}'")
+    analyzer: SentimentAnalyzer = request.app.state.sentiment_analyzer
+
+    async def event_generator():
+        # Clear the initial "waiting..." message on the client.
+        # hx-swap-oob="innerHTML" swaps this div out-of-band without affecting the target.
+        yield f"event: sentiment_update\ndata: <div id='sentiment-results' hx-swap-oob='innerHTML'></div>\n\n"
         
-    # In a real app, this would be the output of your ML model.
-    mock_forecast = {
-        "coin_id": coin_id,
-        "prediction_in_24h": "up",
-        "confidence": 0.78,
-        "detail": "This is a mock forecast. A real implementation requires a data science model."
-    }
-    return mock_forecast
-
-# --- Main execution (for development) ---
+        # Listen for new results from the analyzer's internal queue.
+        async for result_payload in analyzer.stream_results():
+            try:
+                result = result_payload['result']
+                label = str(result.get('label', 'NEUTRAL')).lower()
+                score = result.get('score', 0.0) * 100
+                text = result_payload['text']
+                
+                # Dynamically build the HTML fragment to be sent to the client.
+                html_fragment = f"""
+                <div>
+                    <blockquote>{text}</blockquote>
+                    <p>
+                        <strong>Result:</strong> 
+                        <span class="sentiment-{label}">{label.upper()}</span> 
+                        (Confidence: {score:.1f}%)
+                    </p>
+                </div>
+                """
+                # Send the fragment using our custom event name.
+                yield f"event: sentiment_update\ndata: {html_fragment.replace('\n', '')}\n\n"
+            except (KeyError, TypeError):
+                continue # Ignore malformed payloads
+
+    return StreamingResponse(event_generator(), media_type="text/event-stream")
+
+# --- Main execution block for local development ---
 if __name__ == "__main__":
-    # To run: uvicorn main:app --reload --port 7860
     import uvicorn
-    uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=True)
+    # Correct run command for a file named 'app.py'
+    uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=True)