Update app/app.py

app/app.py

@@ -1,171 +1,175 @@
 """
-The Sentinel TradeFlow Protocol - Main Application
-
-Orchestrates the 3-tier intelligence funnel:
-1. Ingests a (mock) real-time data stream.
-2. Filters events with the local Tier 1 SentimentEngine.
-3. Escalates high-conviction events to the Tier 2 GeminiAnalyzer.
-4. Generates actionable trade hypotheses with the Tier 3 Strategy Engine.
-5. Pushes final signals to the Command Center UI.
+CryptoSentinel Pro — 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.
+- Serves the interactive frontend and provides all necessary API endpoints.
 """
 import asyncio
 import json
 import os
 from contextlib import asynccontextmanager
-from typing import Optional, Dict
+from typing import Optional, Union
 
 import httpx
-from fastapi import FastAPI, Request, BackgroundTasks, Form
+from fastapi import FastAPI, Request, BackgroundTasks
 from fastapi.responses import HTMLResponse, StreamingResponse
 from fastapi.templating import Jinja2Templates
+from pydantic import BaseModel, constr
 
-# Import our intelligence modules
+# Correct imports using relative paths
+from .price_fetcher import PriceFetcher
 from .gemini_analyzer import GeminiAnalyzer
-from .sentiment_engine import LocalSentimentFilter
-
-# --- Tier 3: The Strategist ---
-def generate_trade_hypothesis(analysis: dict) -> Optional[Dict]:
-    """A simple rules-based engine to generate an actionable signal."""
-    sentiment = analysis.get("sentiment")
-    impact = analysis.get("impact")
-    score = analysis.get("sentiment_score", 0.0)
-    
-    # High-conviction rules
-    if impact == "HIGH" and sentiment == "NEGATIVE" and score < -0.7:
-        return {"type": "HYPOTHETICAL SHORT", "confidence": "HIGH", "reason": "High impact, strongly negative news detected."}
-    if impact == "HIGH" and sentiment == "POSITIVE" and score > 0.7:
-        return {"type": "HYPOTHETICAL LONG", "confidence": "HIGH", "reason": "High impact, strongly positive news detected."}
-    
-    # Medium-conviction rules
-    if impact == "MEDIUM" and sentiment == "NEGATIVE" and score < -0.5:
-        return {"type": "HYPOTHETICAL SHORT", "confidence": "MEDIUM", "reason": "Medium impact, negative news."}
-    if impact == "MEDIUM" and sentiment == "POSITIVE" and score > 0.5:
-        return {"type": "HYPOTHETICAL LONG", "confidence": "MEDIUM", "reason": "Medium impact, positive news."}
-        
-    return None
-
-# --- Mock Real-Time Data Feed & Pipeline Orchestration ---
-async def real_time_intelligence_pipeline(app: FastAPI):
-    """Mocks a high-frequency WebSocket news feed and runs it through the 3-tier funnel."""
-    await asyncio.sleep(5) # Initial delay to let UI connect
-    print("🚀 [Pipeline] Real-time intelligence pipeline is active.")
-    
-    # A more realistic stream of headlines
-    mock_headlines = [
-        ("Coinbase reports minor outage, services restored.", 5),
-        ("New memecoin 'ShibaCat' gains 20% on low volume.", 3),
-        ("BREAKING: US Federal Reserve signals potential for surprise interest rate hike next month.", 8),
-        ("Ethereum developer announces successful testnet merge for upcoming 'Prague' upgrade.", 6),
-        ("CEO of major crypto fund says market is 'overheated'.", 4),
-        ("MASSIVE EXPLOIT: Cross-chain bridge 'Wormhole' drained of $150M in ETH and SOL.", 7),
-        ("BlackRock files updated S-1 form for its spot Bitcoin ETF.", 5),
-        ("Polygon announces major partnership with a leading gaming studio.", 4),
-    ]
-
-    for headline, delay in mock_headlines:
-        print(f"🔥 [Tier 1] Ingested: '{headline}'")
-        
-        # Tier 1 Analysis: Fast, local filtering
-        local_analysis = LocalSentimentFilter.analyze(headline)
-        
-        # Trigger Condition for Tier 2: Is sentiment strong enough?
-        if abs(local_analysis['score']) > 0.65 or local_analysis['label'].lower() != 'neutral':
-            print(f"⚡️ [Tier 2 Triggered] Event '{headline[:30]}...' escalated to Gemini. Reason: Local sentiment {local_analysis['label']} ({local_analysis['score']:.2f})")
-            
-            analyzer: GeminiAnalyzer = app.state.gemini_analyzer
-            gemini_analysis = await analyzer.analyze_text(headline)
-            
-            # Tier 3: Generate actionable signal
-            signal = generate_trade_hypothesis(gemini_analysis)
-            
-            if signal:
-                print(f"🎯 [Tier 3] Actionable Signal Generated: {signal['type']} with {signal['confidence']} confidence.")
-                final_payload = {"signal": signal, "analysis": gemini_analysis, "headline": headline}
-                await app.state.signal_queue.put(final_payload)
-        
-        await asyncio.sleep(delay)
-    print("✅ [Pipeline] Mock real-time feed complete.")
+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 ---
 
-# --- Application Lifespan ---
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    """Manages application startup and shutdown events."""
+    """
+    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.signal_queue = asyncio.Queue()
-        
-        # Warm up the local model on startup
-        LocalSentimentFilter.analyze("Warming up FinBERT model...")
-        
-        # Start the intelligence pipeline as a background task
-        pipeline_task = asyncio.create_task(real_time_intelligence_pipeline(app))
+        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()
+
+        price_task = asyncio.create_task(
+            run_periodic_updates(app.state.price_fetcher, interval_seconds=30)
+        )
+        news_task = asyncio.create_task(
+            run_periodic_news_analysis(app, interval_seconds=900)
+        )
         
-        print("🚀 Sentinel TradeFlow Protocol is online.")
+        print("🚀 CryptoSentinel Pro started successfully.")
         yield
         
-        print("⏳ Shutting down Sentinel protocols...")
-        pipeline_task.cancel()
+        print("⏳ Shutting down background tasks...")
+        price_task.cancel()
+        news_task.cancel()
         try:
-            await pipeline_task
+            await asyncio.gather(price_task, news_task)
         except asyncio.CancelledError:
-            print("Intelligence pipeline successfully shut down.")
-        print("✅ Sentinel Protocol offline.")
+            print("Background tasks cancelled successfully.")
+        print("✅ Shutdown complete.")
 
-# --- App Initialization ---
-app = FastAPI(title="Sentinel TradeFlow", lifespan=lifespan)
+async def run_periodic_updates(fetcher: PriceFetcher, interval_seconds: int):
+    """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."""
+    while True:
+        print("📰 Fetching latest crypto news for automated analysis...")
+        try:
+            top_headlines = app.state.news_api.get_everything(
+                q='bitcoin OR ethereum OR crypto OR blockchain',
+                language='en',
+                sort_by='publishedAt',
+                page_size=5
+            )
+            analyzer: GeminiAnalyzer = app.state.gemini_analyzer
+            for article in top_headlines.get('articles', []):
+                title = article.get('title')
+                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)
+        except Exception as e:
+            print(f"❌ Error during news fetching or analysis: {e}")
+            
+        await asyncio.sleep(interval_seconds)
+
+# --- FastAPI App Initialization ---
+
+app = FastAPI(title="CryptoSentinel Pro", lifespan=lifespan)
 templates = Jinja2Templates(directory="templates")
 
 # --- HTML Rendering Helper ---
-def render_signal_card(payload: dict) -> str:
-    """Renders the final signal payload into a rich HTML card."""
-    signal = payload.get("signal", {})
-    analysis = payload.get("analysis", {})
-    headline = payload.get("headline", "N/A")
-    
-    signal_type = signal.get("type", "INFO")
-    confidence = signal.get("confidence", "N/A")
-    
-    # Dynamic styling based on signal
-    if "SHORT" in signal_type:
-        card_class = "signal-short"
-        icon = "📉"
-    elif "LONG" in signal_type:
-        card_class = "signal-long"
-        icon = "📈"
-    else:
-        card_class = ""
-        icon = "ℹ️"
 
+def render_analysis_card(payload: dict, is_news: bool = False) -> 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>'
+    impact_class = f"impact-{s.get('impact', 'low').lower()}"
+    sentiment_class = f"sentiment-{s.get('sentiment', 'neutral').lower()}"
     return f"""
-    <div class="card {card_class}">
-        <header class="signal-header">
-            <span>{icon} {signal_type}</span>
-            <span>Confidence: <strong>{confidence}</strong></span>
-        </header>
-        <p class="headline"><strong>Source Headline:</strong> {headline}</p>
-        <p><strong>Sentinel's Assessment:</strong> {analysis.get('summary', 'N/A')}</p>
+    <div class="card {impact_class}">
+        <blockquote>{text_to_show}</blockquote>
+        <div class="grid">
+            <div><strong>Sentiment:</strong> <span class="{sentiment_class}">{s.get('sentiment')} ({s.get('sentiment_score', 0):.2f})</span></div>
+            <div><strong>Impact:</strong> {s.get('impact')}</div>
+        </div>
         <div class="grid">
-            <div><strong>Impact:</strong> {analysis.get('impact')}</div>
-            <div><strong>Topic:</strong> {analysis.get('topic')}</div>
-            <div><strong>Entities:</strong> {', '.join(analysis.get('entities', []))}</div>
+            <div><strong>Topic:</strong> {s.get('topic')}</div>
+            <div><strong>Entities:</strong> {', '.join(s.get('entities', []))}</div>
         </div>
     </div>
     """
 
 # --- API Endpoints ---
+
 @app.get("/", response_class=HTMLResponse)
-async def serve_command_center(request: Request):
+async def serve_dashboard(request: Request):
     return templates.TemplateResponse("index.html", {"request": request})
 
-@app.get("/api/signals/stream")
-async def signal_stream(request: Request):
-    """SSE stream for pushing generated trade hypotheses to the UI."""
-    queue: asyncio.Queue = request.app.state.signal_queue
+@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
     async def event_generator():
         while True:
             payload = await queue.get()
-            html = render_signal_card(payload)
+            html = render_analysis_card(payload, is_news=True)
             data_payload = html.replace('\n', '')
-            yield f"event: new_signal\ndata: {data_payload}\n\n"
+            sse_message = f"event: news_update\ndata: {data_payload}\n\n"
+            yield sse_message
     return StreamingResponse(event_generator(), media_type="text/event-stream")