Update app/app.py

app/app.py

@@ -1,10 +1,10 @@
 """
-CryptoSentinel Pro — High-performance FastAPI application.
+Sentinel TradeFlow Protocol — High-performance FastAPI application.
 
 This is the main entry point that orchestrates the entire application.
 - Integrates an asynchronous PriceFetcher for live market data.
 - Integrates a sophisticated GeminiAnalyzer for deep text analysis.
-- Implements an automated pipeline to fetch, analyze, and stream top crypto news.
+- Implements an automated pipeline to fetch, analyze, and stream trading signals.
 - Serves the interactive frontend and provides all necessary API endpoints.
 """
 import asyncio
@@ -12,25 +12,17 @@ import json
 import os
 from contextlib import asynccontextmanager
 from typing import Optional, Union
-from newsapi import NewsApiClient
 
 import httpx
-from fastapi import FastAPI, Request, BackgroundTasks
+from fastapi import FastAPI, Request
 from fastapi.responses import HTMLResponse, StreamingResponse
 from fastapi.templating import Jinja2Templates
-from pydantic import BaseModel, constr
 
-# Correct imports using relative paths
-from .price_fetcher import PriceFetcher
-from .gemini_analyzer import GeminiAnalyzer
+# Import our modular, asynchronous service classes
+from price_fetcher import PriceFetcher
+from gemini_analyzer import GeminiAnalyzer
 from newsapi import NewsApiClient
 
-# --- Pydantic Model for API Input Validation ---
-
-class SentimentRequest(BaseModel):
-    """Ensures the text for sentiment analysis is a non-empty string."""
-    text: constr(strip_whitespace=True, min_length=1)
-
 # --- Application Lifespan for Resource Management ---
 
 @asynccontextmanager
@@ -40,21 +32,23 @@ async def lifespan(app: FastAPI):
     lifespan context manager.
     """
     async with httpx.AsyncClient() as client:
+        # Instantiate and store all services in the application state.
         app.state.price_fetcher = PriceFetcher(client=client, coins=["bitcoin", "ethereum", "dogecoin"])
         app.state.gemini_analyzer = GeminiAnalyzer(client=client)
         app.state.news_api = NewsApiClient(api_key=os.getenv("NEWS_API_KEY"))
 
-        app.state.sentiment_queue: asyncio.Queue = asyncio.Queue()
-        app.state.news_queue: asyncio.Queue = asyncio.Queue()
+        # Create a queue for the real-time signal feed
+        app.state.signal_queue: asyncio.Queue = asyncio.Queue()
 
+        # Create cancellable background tasks for periodic updates.
         price_task = asyncio.create_task(
-            run_periodic_updates(app.state.price_fetcher, interval_seconds=30)
+            run_periodic_updates(app.state.price_fetcher, interval_seconds=60)
         )
         news_task = asyncio.create_task(
-            run_periodic_news_analysis(app, interval_seconds=900)
+            run_periodic_news_analysis(app, interval_seconds=900)  # Run every 15 minutes
         )
         
-        print("🚀 CryptoSentinel Pro started successfully.")
+        print("🚀 Sentinel TradeFlow Protocol started successfully.")
         yield
         
         print("⏳ Shutting down background tasks...")
@@ -67,13 +61,13 @@ async def lifespan(app: FastAPI):
         print("✅ Shutdown complete.")
 
 async def run_periodic_updates(fetcher: PriceFetcher, interval_seconds: int):
-    """Periodically updates prices."""
+    """A robust asyncio background task that periodically updates prices."""
     while True:
         await fetcher.update_prices_async()
         await asyncio.sleep(interval_seconds)
 
 async def run_periodic_news_analysis(app: FastAPI, interval_seconds: int):
-    """Periodically fetches and analyzes crypto news."""
+    """Fetches, analyzes, and queues top crypto news periodically."""
     while True:
         print("📰 Fetching latest crypto news for automated analysis...")
         try:
@@ -89,7 +83,7 @@ async def run_periodic_news_analysis(app: FastAPI, interval_seconds: int):
                 if title and "[Removed]" not in title:
                     analysis = await analyzer.analyze_text(title)
                     analysis['url'] = article.get('url')
-                    await app.state.news_queue.put(analysis)
+                    await app.state.signal_queue.put(analysis)
         except Exception as e:
             print(f"❌ Error during news fetching or analysis: {e}")
             
@@ -97,20 +91,21 @@ async def run_periodic_news_analysis(app: FastAPI, interval_seconds: int):
 
 # --- FastAPI App Initialization ---
 
-app = FastAPI(title="CryptoSentinel Pro", lifespan=lifespan)
+app = FastAPI(title="Sentinel TradeFlow Protocol", lifespan=lifespan)
 templates = Jinja2Templates(directory="templates")
 
 # --- HTML Rendering Helper ---
 
-def render_analysis_card(payload: dict, is_news: bool = False) -> str:
+def render_signal_card(payload: dict) -> str:
     """Renders a dictionary of analysis into a styled HTML card."""
     s = payload
-    text_to_show = s.get('summary', 'Analysis failed or not available.')
-    if is_news:
-        url = s.get('url', '#')
-        text_to_show = f'<a href="{url}" target="_blank" rel="noopener noreferrer">{s.get("summary", "N/A")}</a>'
+    url = s.get('url', '#')
+    summary = s.get('summary', 'Analysis failed or not available.')
+    text_to_show = f'<a href="{url}" target="_blank" rel="noopener noreferrer">{summary}</a>'
+
     impact_class = f"impact-{s.get('impact', 'low').lower()}"
     sentiment_class = f"sentiment-{s.get('sentiment', 'neutral').lower()}"
+
     return f"""
     <div class="card {impact_class}">
         <blockquote>{text_to_show}</blockquote>
@@ -129,48 +124,19 @@ def render_analysis_card(payload: dict, is_news: bool = False) -> str:
 
 @app.get("/", response_class=HTMLResponse)
 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_fragment(request: Request):
-    price_fetcher: PriceFetcher = request.app.state.price_fetcher
-    prices = price_fetcher.get_current_prices()
-    html_fragment = "".join(
-        f"<div><strong>{coin.capitalize()}:</strong> ${price:,.2f}</div>" if isinstance(price, (int, float))
-        else f"<div><strong>{coin.capitalize()}:</strong> {price}</div>"
-        for coin, price in prices.items()
-    )
-    return HTMLResponse(content=html_fragment)
-
-@app.post("/api/sentiment")
-async def analyze_sentiment(payload: SentimentRequest, request: Request, background_tasks: BackgroundTasks):
-    analyzer: GeminiAnalyzer = request.app.state.gemini_analyzer
-    async def analysis_task_wrapper():
-        analysis_result = await analyzer.analyze_text(payload.text)
-        await request.app.state.sentiment_queue.put(analysis_result)
-    background_tasks.add_task(analysis_task_wrapper)
-    return HTMLResponse(content="<small>✅ Queued for deep analysis...</small>")
-
-@app.get("/api/sentiment/stream")
-async def sentiment_stream(request: Request):
-    queue: asyncio.Queue = request.app.state.sentiment_queue
-    async def event_generator():
-        while True:
-            payload = await queue.get()
-            html = render_analysis_card(payload)
-            data_payload = html.replace('\n', '')
-            sse_message = f"event: sentiment_update\ndata: {data_payload}\n\n"
-            yield sse_message
-    return StreamingResponse(event_generator(), media_type="text/event-stream")
-
-@app.get("/api/news/stream")
-async def news_stream(request: Request):
-    queue: asyncio.Queue = request.app.state.news_queue
+@app.get("/api/signals/stream")
+async def signal_stream(request: Request):
+    """SSE stream for the automated Signal Stream."""
+    queue: asyncio.Queue = request.state.signal_queue
     async def event_generator():
         while True:
             payload = await queue.get()
-            html = render_analysis_card(payload, is_news=True)
+            html = render_signal_card(payload)
             data_payload = html.replace('\n', '')
-            sse_message = f"event: news_update\ndata: {data_payload}\n\n"
+            # Use a generic 'message' event, which HTMX listens to by default
+            sse_message = f"event: message\ndata: {data_payload}\n\n"
             yield sse_message
     return StreamingResponse(event_generator(), media_type="text/event-stream")