Update app/main.py

app/main.py

@@ -1,11 +1,10 @@
 """
 CryptoSentinel AI — High-performance FastAPI application.
 
-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.
+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
@@ -17,44 +16,41 @@ from fastapi.responses import HTMLResponse, StreamingResponse
 from fastapi.templating import Jinja2Templates
 from pydantic import BaseModel, constr
 
+# These relative imports will now work correctly.
 from .price_fetcher import PriceFetcher
 from .sentiment import SentimentAnalyzer
 
-# --- Configuration & Models ---
+
+# --- Pydantic Model for API Input Validation ---
 
 class SentimentRequest(BaseModel):
-    """Pydantic model for validating sentiment analysis requests."""
+    """Ensures the text for sentiment analysis is a non-empty string."""
     text: constr(strip_whitespace=True, min_length=1)
 
-# --- Application Lifespan Management ---
+# --- Application Lifespan for Resource Management ---
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """
-    Manages application startup and shutdown events. This is the modern
-    replacement for @app.on_event("startup") and "shutdown".
+    Manages application startup and shutdown events using the modern
+    lifespan context manager.
     """
-    # -- Startup --
-    # Create a single, shared httpx client for the application's lifespan.
+    # On startup:
     async with httpx.AsyncClient() as client:
-        # Initialize our stateful services
-        price_fetcher = PriceFetcher(client=client, coins=["bitcoin", "ethereum", "dogecoin"])
-        sentiment_analyzer = SentimentAnalyzer()
-
-        # Store service instances in the app's state for access in routes
-        app.state.price_fetcher = price_fetcher
-        app.state.sentiment_analyzer = sentiment_analyzer
+        # Instantiate and store our services in the application state.
+        app.state.price_fetcher = PriceFetcher(client=client, coins=["bitcoin", "ethereum", "dogecoin"])
+        app.state.sentiment_analyzer = SentimentAnalyzer(client=client)
         app.state.request_counter = 0
 
-        # Create a cancellable background task for periodic price updates
+        # Create a cancellable background task for continuous price updates.
         price_update_task = asyncio.create_task(
-            run_periodic_updates(price_fetcher, interval_seconds=10)
+            run_periodic_updates(app.state.price_fetcher, interval_seconds=10)
         )
         
         print("🚀 CryptoSentinel AI started successfully.")
-        yield  # The application is now running
+        yield
         
-        # -- Shutdown --
+        # On shutdown:
         print("⏳ Shutting down background tasks...")
         price_update_task.cancel()
         try:
@@ -64,79 +60,72 @@ async def lifespan(app: FastAPI):
         print("✅ Shutdown complete.")
 
 async def run_periodic_updates(fetcher: PriceFetcher, interval_seconds: int):
-    """A simple, robust asyncio background task runner."""
+    """A robust asyncio background task that periodically updates prices."""
     while True:
         await fetcher.update_prices_async()
         await asyncio.sleep(interval_seconds)
 
 # --- FastAPI App Initialization ---
 
-templates = Jinja2Templates(directory="app/templates")
 app = FastAPI(title="CryptoSentinel AI", lifespan=lifespan)
+# This path assumes the app is run from the root directory.
+templates = Jinja2Templates(directory="app/templates")
 
-# --- Routes ---
-
+# --- API Endpoints ---
+# ... (The rest of the file is unchanged) ...
 @app.get("/", response_class=HTMLResponse)
-async def index(request: Request):
-    """Renders the main single-page application view."""
+async def serve_dashboard(request: Request):
     return templates.TemplateResponse("index.html", {"request": request})
 
 @app.get("/api/prices", response_class=HTMLResponse)
 async def get_prices_fragment(request: Request):
-    """
-    Returns an HTML fragment with the latest crypto prices.
-    Designed to be called by HTMX.
-    """
     price_fetcher: PriceFetcher = request.app.state.price_fetcher
     prices = price_fetcher.get_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("/api/sentiment")
-async def analyze_sentiment(
-    payload: SentimentRequest,
-    request: Request,
-    background_tasks: BackgroundTasks
-):
-    """
-    Accepts text for sentiment analysis, validates it, and queues it
-    for processing in the background.
-    """
+async def analyze_sentiment(payload: SentimentRequest, request: Request, background_tasks: BackgroundTasks):
     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}
+    return HTMLResponse(content="<small>Queued for analysis...</small>")
 
 @app.get("/api/sentiment/stream")
 async def sentiment_stream(request: Request):
-    """
-    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():
-        while True:
+        yield f"event: sentiment_update\ndata: <div id='sentiment-results' hx-swap-oob='innerHTML'></div>\n\n"
+        async for result_payload in analyzer.stream_results():
             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")
+                result = result_payload['result']
+                label = str(result.get('label', 'NEUTRAL')).lower()
+                score = result.get('score', 0.0) * 100
+                text = result_payload['text']
+                html_fragment = f"""
+                <div>
+                    <blockquote>{text}</blockquote>
+                    <p>
+                        <strong>Result:</strong> 
+                        <span class="sentiment-{label}">{label.upper()}</span> 
+                        (Confidence: {score:.1f}%)
+                    </p>
+                </div>
+                """
+                data_payload = html_fragment.replace('\n', '')
+                sse_message = f"event: sentiment_update\ndata: {data_payload}\n\n"
+                yield sse_message
+            except (KeyError, TypeError):
+                continue
+    return StreamingResponse(event_generator(), media_type="text/event-stream")
+
+# This block is now mostly for IDEs, the primary run method is the uvicorn command.
+if __name__ == "__main__":
+    # Note: Running this file directly (`python app/app.py`) will fail due to relative imports.
+    # Use the command: `uvicorn app.app:app --reload` from the project root.
+    print("To run this application, use the command from the root directory:")
+    print("uvicorn app.app:app --host 0.0.0.0 --port 7860 --reload")