# Live Market Monitoring + Congressional Trading Analysis

## 🎯 What's Possible vs Impossible

### ❌ **NOT Possible:**
- Identify WHO is buying/selling in real-time
- Match live trades to specific Congress members
- See congressional trades before they're disclosed

### ✅ **IS Possible:**
- Track unusual market activity in real-time
- Monitor stocks Congress members historically trade
- Compare unusual activity to later disclosures
- Detect patterns (timing, sectors, etc.)

---

## 🔄 **Two-Phase Monitoring System**

### **Phase 1: Real-Time Market Monitoring**
Monitor unusual activity in stocks Congress trades:
- Unusual options flow
- Large block trades
- Volatility spikes
- Volume anomalies

### **Phase 2: Retroactive Analysis (30-45 days later)**
When disclosures come in:
- Match disclosed trades to earlier unusual activity
- Identify if Congress bought BEFORE or AFTER spikes
- Calculate timing advantage (if any)
- Build pattern database

---

## 📊 **Implementation: Watchlist-Based Monitoring**

### **Concept:**

```
Step 1: Congress Member Trades (Historical)
  Nancy Pelosi often trades: NVDA, MSFT, GOOGL, AAPL
  Dan Crenshaw often trades: XOM, CVX, LMT, BA
  
Step 2: Create Monitoring Watchlist
  Monitor these tickers in real-time for:
  - Unusual options activity
  - Large block trades
  - Price/volume anomalies
  
Step 3: When Disclosure Appears (30-45 days later)
  Compare:
  - Did they buy BEFORE unusual activity? (Suspicious)
  - Did they buy AFTER? (Following market)
  - What was the timing advantage?
```

---

## 🛠️ **Data Sources for Live Market Monitoring**

### **Free/Low-Cost Options:**

1. **Yahoo Finance (yfinance)**
   - ✅ Real-time quotes (15-min delay free)
   - ✅ Historical options data
   - ✅ Volume data
   - ❌ Not true real-time for options flow

2. **Unusual Whales API**
   - ✅ Options flow data
   - ✅ Unusual activity alerts
   - 💰 Paid ($50-200/month)
   - https://unusualwhales.com/

3. **Tradier API**
   - ✅ Real-time market data
   - ✅ Options chains
   - 💰 Paid but affordable ($10-50/month)
   - https://tradier.com/

4. **FlowAlgo**
   - ✅ Options flow tracking
   - ✅ Dark pool data
   - 💰 Paid ($99-399/month)
   - https://www.flowalgo.com/

5. **Polygon.io**
   - ✅ Real-time stock data
   - ✅ Options data
   - 💰 Free tier + paid plans
   - https://polygon.io/

### **Best Free Option: Build Your Own with yfinance**

Track volume/price changes every 5 minutes for congressional watchlist tickers.

---

## 💡 **Practical Hybrid System**

### **What We Can Build:**

```python
# Pseudo-code for hybrid monitoring

# 1. Get stocks Congress trades
congress_tickers = get_tickers_congress_trades()
# Result: ["NVDA", "MSFT", "TSLA", "AAPL", "SPY", ...]

# 2. Monitor these tickers for unusual activity
while market_open():
    for ticker in congress_tickers:
        current_data = get_realtime_data(ticker)
        
        if is_unusual_activity(current_data):
            log_alert({
                "ticker": ticker,
                "type": "unusual_volume",  # or "price_spike", "options_flow"
                "timestamp": now(),
                "details": current_data
            })

# 3. When disclosures appear (30-45 days later)
new_disclosures = fetch_congressional_trades()

for disclosure in new_disclosures:
    # Check if we saw unusual activity BEFORE their trade
    prior_alerts = get_alerts_before_date(
        ticker=disclosure.ticker,
        before_date=disclosure.transaction_date
    )
    
    if prior_alerts:
        # They bought BEFORE unusual activity = Potential inside info
        flag_suspicious(disclosure, prior_alerts)
    else:
        # They bought AFTER unusual activity = Following market
        flag_following(disclosure)
```

---

## 📈 **Example: Nancy Pelosi NVDA Trade Analysis**

### **Timeline:**

```
Nov 10, 2024:
  🔔 ALERT: NVDA unusual call options activity
     Volume: 10x average
     Strike: $500 (2 weeks out)
     
Nov 15, 2024:
  💰 Someone buys NVDA (unknown who at the time)
  
Nov 18, 2024:
  📰 NVDA announces new AI chip
  📈 Stock jumps 15%
  
Dec 15, 2024:
  📋 Disclosure: Nancy Pelosi bought NVDA on Nov 15
     Value: $15,001-$50,000
     
ANALYSIS:
  ✅ She bought AFTER unusual options activity (Nov 10)
  ❓ She bought BEFORE announcement (Nov 18)
  ⏱️ Timing: 3 days before major news
  🚩 Flag: Investigate if announcement was public knowledge
```

---

## 🎯 **Recommended Approach**

### **Phase 1: Build Congressional Ticker Watchlist**

```python
# scripts/build_ticker_watchlist.py

from pote.db import get_session
from pote.db.models import Trade, Security
from sqlalchemy import func

def get_most_traded_tickers(limit=50):
    """Get tickers Congress trades most frequently."""
    session = next(get_session())
    
    results = (
        session.query(
            Security.ticker,
            func.count(Trade.id).label('trade_count')
        )
        .join(Trade)
        .group_by(Security.ticker)
        .order_by(func.count(Trade.id).desc())
        .limit(limit)
        .all()
    )
    
    return [r[0] for r in results]

# Result: Top 50 tickers Congress trades
# Use these for real-time monitoring
```

### **Phase 2: Real-Time Monitoring (Simple)**

```python
# scripts/monitor_congressional_tickers.py

import yfinance as yf
from datetime import datetime, timedelta
import time

def monitor_tickers(tickers, interval_minutes=5):
    """Monitor tickers for unusual activity."""
    
    baseline = {}  # Store baseline metrics
    
    while True:
        for ticker in tickers:
            try:
                stock = yf.Ticker(ticker)
                current = stock.history(period="1d", interval="1m")
                
                if len(current) > 0:
                    latest = current.iloc[-1]
                    
                    # Check for unusual volume
                    avg_volume = current['Volume'].mean()
                    if latest['Volume'] > avg_volume * 3:
                        alert(f"🔔 {ticker}: Unusual volume spike!")
                    
                    # Check for price movement
                    price_change = (latest['Close'] - current['Open'].iloc[0]) / current['Open'].iloc[0]
                    if abs(price_change) > 0.05:  # 5% move
                        alert(f"📈 {ticker}: {price_change:.2%} move today!")
                        
            except Exception as e:
                print(f"Error monitoring {ticker}: {e}")
        
        time.sleep(interval_minutes * 60)
```

### **Phase 3: Retroactive Analysis**

When disclosures appear, analyze timing:

```python
# scripts/analyze_trade_timing.py

def analyze_disclosure_timing(disclosure):
    """
    When a disclosure appears, check if there was unusual
    activity BEFORE the trade date.
    """
    
    # Get alerts from 7 days before trade
    lookback_start = disclosure.transaction_date - timedelta(days=7)
    lookback_end = disclosure.transaction_date
    
    alerts = get_alerts_in_range(
        ticker=disclosure.ticker,
        start=lookback_start,
        end=lookback_end
    )
    
    if alerts:
        return {
            "suspicious": True,
            "reason": "Unusual activity before trade",
            "alerts": alerts
        }
    
    # Check if trade was before major price movement
    post_trade_price = get_price_change(
        ticker=disclosure.ticker,
        start=disclosure.transaction_date,
        days=30
    )
    
    if post_trade_price > 0.10:  # 10% gain
        return {
            "notable": True,
            "reason": f"Stock up {post_trade_price:.1%} after trade",
            "gain": post_trade_price
        }
```

---

## 🚨 **Realistic Expectations**

### **What This System Will Do:**
✅ Monitor stocks Congress members historically trade
✅ Alert on unusual market activity in those stocks
✅ Retroactively correlate disclosures with earlier alerts
✅ Identify timing patterns and potential advantages
✅ Build database of congressional trading patterns

### **What This System WON'T Do:**
❌ Identify WHO is buying in real-time
❌ Give you advance notice of congressional trades
❌ Provide real-time inside information
❌ Allow you to "front-run" Congress

### **Legal & Ethical:**
✅ All data is public
✅ Analysis is retrospective
✅ For research and transparency
✅ Not market manipulation
❌ Cannot and should not be used to replicate potentially illegal trades

---

## 📊 **Proposed Implementation**

### **New Scripts to Create:**

1. **`scripts/build_congressional_watchlist.py`**
   - Analyzes historical trades
   - Identifies most-traded tickers
   - Creates monitoring watchlist

2. **`scripts/monitor_market_live.py`**
   - Monitors watchlist tickers
   - Detects unusual activity
   - Logs alerts to database

3. **`scripts/analyze_disclosure_timing.py`**
   - When new disclosures appear
   - Checks for prior unusual activity
   - Flags suspicious timing

4. **`scripts/generate_timing_report.py`**
   - Shows disclosures with unusual timing
   - Calculates timing advantage
   - Identifies patterns

### **New Database Tables:**

```sql
-- Track unusual market activity
CREATE TABLE market_alerts (
    id SERIAL PRIMARY KEY,
    ticker VARCHAR(20),
    alert_type VARCHAR(50),  -- 'unusual_volume', 'price_spike', 'options_flow'
    timestamp TIMESTAMP,
    details JSONB,
    created_at TIMESTAMP DEFAULT NOW()
);

-- Link disclosures to prior alerts
CREATE TABLE disclosure_timing_analysis (
    id SERIAL PRIMARY KEY,
    trade_id INTEGER REFERENCES trades(id),
    suspicious_flag BOOLEAN,
    timing_score DECIMAL(5,2),  -- 0-100 score
    prior_alerts JSONB,
    post_trade_performance DECIMAL(10,4),
    created_at TIMESTAMP DEFAULT NOW()
);
```

---

## 🎯 **Summary**

### **Your Question:**
> "Can we read live trades being made and compare them to a name?"

### **Answer:**
❌ **No** - Live trades are anonymous, can't identify individuals

✅ **BUT** - You CAN:
1. Monitor unusual activity in stocks Congress trades
2. Log these alerts in real-time
3. When disclosures appear (30-45 days later), correlate them
4. Identify if Congress bought BEFORE or AFTER unusual activity
5. Build patterns database of timing and performance

### **This Gives You:**
- ✅ Transparency on timing advantages
- ✅ Pattern detection across officials
- ✅ Research-grade analysis
- ✅ Historical correlation data

### **This Does NOT Give You:**
- ❌ Real-time identity of traders
- ❌ Advance notice of congressional trades
- ❌ Ability to "front-run" disclosures

---

## 🚀 **Would You Like Me To Build This?**

I can create:
1. ✅ Real-time monitoring system for congressional tickers
2. ✅ Alert logging and analysis
3. ✅ Timing correlation when disclosures appear
4. ✅ Pattern detection and reporting

This would be **Phase 2.5** of POTE - the "timing analysis" module.

**Should I proceed with implementation?**