Update app/app.py

app/app.py

@@ -1,50 +1,32 @@
 """
 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 trading signals.
-- Serves the interactive frontend and provides all necessary API endpoints.
+This version includes a live price ticker and robust, structured analysis.
 """
 import asyncio
-import json
 import os
 from contextlib import asynccontextmanager
 from typing import Optional, Union
+from datetime import datetime, timezone
 
 import httpx
 from fastapi import FastAPI, Request
 from fastapi.responses import HTMLResponse, StreamingResponse
 from fastapi.templating import Jinja2Templates
 
-# Use relative imports because these modules are in the same 'app' package.
 from .price_fetcher import PriceFetcher
 from .gemini_analyzer import GeminiAnalyzer
 from newsapi import NewsApiClient
 
-
-# --- Application Lifespan for Resource Management ---
-
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    """
-    Manages application startup and shutdown events using the modern
-    lifespan context manager.
-    """
     async with httpx.AsyncClient() as client:
         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.signal_queue: asyncio.Queue = asyncio.Queue()
 
-        # Create cancellable background tasks. Let's use a shorter timer for testing.
-        price_task = asyncio.create_task(
-            run_periodic_updates(app.state.price_fetcher, interval_seconds=60)
-        )
-        news_task = asyncio.create_task(
-            run_periodic_news_analysis(app, interval_seconds=300)  # Check news every 5 minutes for debugging
-        )
+        price_task = asyncio.create_task(run_periodic_updates(app.state.price_fetcher, 60))
+        news_task = asyncio.create_task(run_periodic_news_analysis(app, 300))
         
         print("🚀 Sentinel TradeFlow Protocol started successfully.")
         yield
@@ -59,74 +41,63 @@ async def lifespan(app: FastAPI):
         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)
 
 async def run_periodic_news_analysis(app: FastAPI, interval_seconds: int):
-    """Fetches, analyzes, and queues top crypto news periodically with detailed logging."""
+    processed_urls = set()
     while True:
-        print("📰 [1/5] Fetching latest crypto news...")
+        print(f"📰 Fetching news... (have processed {len(processed_urls)} articles so far)")
         try:
             top_headlines = app.state.news_api.get_everything(
-                q='bitcoin OR ethereum OR "binance coin" OR solana OR ripple OR cardano',
-                language='en',
-                sort_by='publishedAt',
-                page_size=5
+                q='(crypto OR bitcoin OR ethereum) AND (regulation OR partnership OR hack OR update OR adoption)',
+                language='en', sort_by='publishedAt', page_size=10
             )
-            
             articles = top_headlines.get('articles', [])
-            print(f"📰 [2/5] NewsAPI call successful. Found {len(articles)} articles.")
+            print(f"📰 Found {len(articles)} articles.")
             
-            if not articles:
-                print("📰 [SKIP] No new articles found in this cycle.")
-                await asyncio.sleep(interval_seconds)
-                continue
-
             analyzer: GeminiAnalyzer = app.state.gemini_analyzer
-            for article in articles:
+            for article in reversed(articles): # Process oldest first
                 title = article.get('title')
-                print(f"📰 [3/5] Processing article: '{title}'")
-
-                if not title or "[Removed]" in title:
-                    print(f"📰 [SKIP] Article has no title or was removed.")
-                    continue
-                
-                print(f"📰 [4/5] Sending to Gemini for analysis...")
-                analysis = await analyzer.analyze_text(title)
-                
-                if analysis.get("error"):
-                    print(f"❌ [SKIP] Gemini analysis failed for '{title}'. Reason: {analysis.get('reason')}")
-                    continue
-                
-                analysis['url'] = article.get('url')
-                await app.state.signal_queue.put(analysis)
-                print(f"✅ [5/5] Signal generated and queued for: '{title}'")
-
+                url = article.get('url')
+                if title and "[Removed]" not in title and url not in processed_urls:
+                    print(f"✨ New article found: '{title}'. Analyzing...")
+                    analysis = await analyzer.analyze_text(title)
+                    if not analysis.get("error"):
+                        analysis['url'] = url
+                        analysis['timestamp'] = datetime.now(timezone.utc).isoformat()
+                        await app.state.signal_queue.put(analysis)
+                        processed_urls.add(url) # Mark as processed
+                        print(f"✅ Signal generated and queued for: '{title}'")
         except Exception as e:
-            print(f"❌❌❌ CRITICAL ERROR in news analysis loop: {e}")
-            
-        print(f"📰 Loop finished. Waiting for {interval_seconds} seconds.")
+            print(f"❌ CRITICAL ERROR in news analysis loop: {e}")
+        
         await asyncio.sleep(interval_seconds)
 
-# --- FastAPI App Initialization ---
-
 app = FastAPI(title="Sentinel TradeFlow Protocol", lifespan=lifespan)
 templates = Jinja2Templates(directory="templates")
 
-# --- HTML Rendering Helper ---
 def render_signal_card(payload: dict) -> str:
-    """Renders a dictionary of analysis into a styled HTML card."""
     s = payload
     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>'
+    summary = s.get('summary', 'N/A')
+    timestamp_str = s.get('timestamp')
+    if timestamp_str:
+        dt_obj = datetime.fromisoformat(timestamp_str)
+        time_ago = f"{dt_obj.strftime('%H:%M:%S UTC')}"
+    else:
+        time_ago = "Just now"
 
+    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()}"
+    
+    # Use Out-of-Band swaps to update the timestamp without re-rendering the whole stream
+    oob_swap = f'<span id="last-signal-time" hx-swap-oob="true">{time_ago}</span>'
 
     return f"""
+    {oob_swap}
     <div class="card {impact_class}">
         <blockquote>{text_to_show}</blockquote>
         <div class="grid">
@@ -140,15 +111,24 @@ def render_signal_card(payload: dict) -> str:
     </div>
     """
 
-# --- API Endpoints ---
 @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})
 
+# NEW ENDPOINT FOR LIVE PRICES
+@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"<span>{coin.capitalize()}: <strong>${price:,.2f}</strong></span>" if isinstance(price, (int, float))
+        else f"<span>{coin.capitalize()}: <strong>{price}</strong></span>"
+        for coin, price in prices.items()
+    )
+    return HTMLResponse(content=html_fragment)
+
 @app.get("/api/signals/stream")
 async def signal_stream(request: Request):
-    """SSE stream for the automated Signal Stream."""
     queue: asyncio.Queue = request.app.state.signal_queue
     async def event_generator():
         while True:
@@ -157,5 +137,4 @@ async def signal_stream(request: Request):
             data_payload = html.replace('\n', '')
             sse_message = f"event: message\ndata: {data_payload}\n\n"
             yield sse_message
-            
     return StreamingResponse(event_generator(), media_type="text/event-stream")