import pandas as pd
import numpy as np
from datetime import datetime
from typing import Dict, List
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class CongressTradeAnalyzer:
    """Analyze congressional stock trades for patterns"""
def __init__(self):
        self.trades = []
        self.members = {}
        self.sectors = {}
def parse_disclosure(self, member: str, ticker: str, action: str,
                        amount: str, date: str, sector: str):
        """Parse congressional trade disclosure"""
trade = {
            'member': member,
            'ticker': ticker,
            'action': action,
            'amount_range': amount,
            'date': pd.to_datetime(date),
            'sector': sector,
            'month': pd.to_datetime(date).month,
            'party': self._identify_party(member)
        }
self.trades.append(trade)
def analyze_tech_consensus(self, sector: str = 'Technology') -> Dict:
        """Find consensus trades in tech sector"""
tech_trades = [t for t in self.trades if t['sector'] == sector]
if not tech_trades:
            return {}
# Count buys vs sells
        buys = [t for t in tech_trades if t['action'] == 'BUY']
        sells = [t for t in tech_trades if t['action'] == 'SELL']
# Find most traded tickers
        ticker_counts = {}
        for trade in tech_trades:
            ticker = trade['ticker']
            ticker_counts[ticker] = ticker_counts.get(ticker, 0) + 1
most_traded = sorted(ticker_counts.items(), key=lambda x: x[1], reverse=True)
return {
            'total_trades': len(tech_trades),
            'buys': len(buys),
            'sells': len(sells),
            'buy_sell_ratio': len(buys) / (len(sells) + 1),
            'consensus': 'BULLISH' if len(buys) > len(sells)  1.5 else 'BEARISH' if len(sells) > len(buys)  1.5 else 'NEUTRAL',
            'most_traded': most_traded[:10],
            'unique_tickers': len(ticker_counts)
        }
def identify_bipartisan_consensus(self, sector: str = 'Technology') -> Dict:
        """Identify trades with bipartisan consensus"""
tech_trades = [t for t in self.trades if t['sector'] == sector]
# Group by ticker
        ticker_consensus = {}
for trade in tech_trades:
            ticker = trade['ticker']
if ticker not in ticker_consensus:
                ticker_consensus[ticker] = {'buys': [], 'sells': [], 'democrats': 0, 'republicans': 0}
if trade['action'] == 'BUY':
                ticker_consensus[ticker]['buys'].append(trade)
            else:
                ticker_consensus[ticker]['sells'].append(trade)
if trade['party'] == 'Democratic':
                ticker_consensus[ticker]['democrats'] += 1
            else:
                ticker_consensus[ticker]['republicans'] += 1
# Find bipartisan consensus
        bipartisan = {}
for ticker, data in ticker_consensus.items():
            if data['democrats'] > 0 and data['republicans'] > 0:
                # Both parties trading same direction
                buy_consensus = len(data['buys']) > len(data['sells'])
if buy_consensus:
                    bipartisan[ticker] = {
                        'direction': 'BUY',
                        'democrats_buying': len([b for b in data['buys'] if b['party'] == 'Democratic']),
                        'republicans_buying': len([b for b in data['buys'] if b['party'] == 'Republican']),
                        'strength': 'STRONG' if data['democrats'] > 1 and data['republicans'] > 1 else 'WEAK'
                    }
return bipartisan
def _identify_party(self, member: str) -> str:
        """Identify party affiliation"""
        # Would use actual member database
        return 'Democratic'
def detect_coordinated_trades(self, window_days: int = 5) -> List[Dict]:
        """Detect coordinated trades (same stock in short timeframe)"""
coordinated = []
# Group trades by ticker
        ticker_groups = {}
        for trade in self.trades:
            ticker = trade['ticker']
            if ticker not in ticker_groups:
                ticker_groups[ticker] = []
            ticker_groups[ticker].append(trade)
# Find coordinated trades
        for ticker, ticker_trades in ticker_groups.items():
            ticker_trades = sorted(ticker_trades, key=lambda x: x['date'])
for i in range(len(ticker_trades) - 1):
                trade1 = ticker_trades[i]
                trade2 = ticker_trades[i + 1]
days_diff = (trade2['date'] - trade1['date']).days
if days_diff <= window_days and trade1['action'] == trade2['action']:
                    coordinated.append({
                        'ticker': ticker,
                        'trade1_member': trade1['member'],
                        'trade2_member': trade2['member'],
                        'action': trade1['action'],
                        'days_apart': days_diff,
                        'coordination_score': 1 - (days_diff / window_days)
                    })
return sorted(coordinated, key=lambda x: x['coordination_score'], reverse=True)
def analyze_quarterly_trends(self) -> Dict:
        """Analyze Q1 2026 trading trends"""
tech_trades = [t for t in self.trades if t['sector'] == 'Technology']
q1_trades = [t for t in tech_trades if t['date'].month in [1, 2, 3]]
buys_by_week = {}
        for trade in q1_trades:
            if trade['action'] == 'BUY':
                week = trade['date'].isocalendar()[1]
                buys_by_week[week] = buys_by_week.get(week, 0) + 1
return {
            'total_q1_trades': len(q1_trades),
            'buys_by_week': buys_by_week,
            'trend': 'increasing_interest' if len(buys_by_week) > 5 else 'stable'
        }

class TechSectorScoringModel:
    """Score tech stocks based on congressional trades"""
def __init__(self, analyzer: CongressTradeAnalyzer):
        self.analyzer = analyzer
def calculate_congressional_score(self, ticker: str,
                                    lookback_days: int = 30) -> float:
        """Calculate score based on congressional trades"""
relevant_trades = [
            t for t in self.analyzer.trades
            if t['ticker'] == ticker and
            (datetime.now() - t['date']).days <= lookback_days
        ]
if not relevant_trades:
            return 0.0
# Score based on:
        # - Buy/sell ratio
        # - Recency (recent trades weighted more)
        # - Party alignment
buys = len([t for t in relevant_trades if t['action'] == 'BUY'])
        sells = len([t for t in relevant_trades if t['action'] == 'SELL'])
buy_ratio = buys / (buys + sells + 1)
# Recency weighting
        weights = []
        for trade in relevant_trades:
            days_old = (datetime.now() - trade['date']).days
            weight = max(0, 1 - (days_old / lookback_days))
            weights.append(weight)
avg_recency = np.mean(weights) if weights else 0
# Final score (-1 to 1, where 1 is strong buy signal)
        score = (2  buy_ratio - 1)  avg_recency
return score
def score_tech_portfolio(self, tickers: List[str]) -> pd.DataFrame:
        """Score multiple tech stocks"""
scores = []
for ticker in tickers:
            score = self.calculate_congressional_score(ticker)
scores.append({
                'ticker': ticker,
                'congressional_score': score,
                'signal': 'BUY' if score > 0.5 else 'SELL' if score < -0.5 else 'HOLD'
            })
return pd.DataFrame(scores).sort_values('congressional_score', ascending=False)
def compare_to_performance(self, ticker: str, current_price: float,
                              congressional_score: float) -> Dict:
        """Compare congressional signal to recent performance"""
return {
            'ticker': ticker,
            'congressional_score': congressional_score,
            'recommendation': self._generate_recommendation(congressional_score),
            'risk_level': 'high' if abs(congressional_score) > 0.7 else 'medium'
        }
def _generate_recommendation(self, score: float) -> str:
        """Generate trading recommendation"""
if score > 0.7:
            return 'STRONG BUY'
        elif score > 0.3:
            return 'BUY'
        elif score < -0.7:
            return 'STRONG SELL'
        elif score < -0.3:
            return 'SELL'
        else:
            return 'HOLD'

class CongressTradingRiskAnalyzer:
    """Analyze risks of trading on congressional signals"""
def assess_legal_risk(self, trade: Dict) -> Dict:
        """Assess legal implications of trading"""
return {
            'legal_risk': 'LOW - Congressional members trades are public disclosures',
            'timing_consideration': 'Disclosures may be delayed by up to 45 days',
            'compliance_note': 'STOCK Act prohibits insiders from profiting on non-public info'
        }
def analyze_false_signal_risk(self, member: str, analyzer: CongressTradeAnalyzer) -> float:
        """Calculate likelihood member makes poor trades"""
member_trades = [t for t in analyzer.trades if t['member'] == member]
if len(member_trades) < 5:
            return 0.7  # High false signal risk with few trades
# Would compare historical trades to market performance
        # Simplified here
return 0.3  # Moderate risk
def evaluate_crowded_trade(self, ticker: str, analyzer: CongressTradeAnalyzer) -> Dict:
        """Evaluate if many congress members are in the same position"""
ticker_trades = [t for t in analyzer.trades if t['ticker'] == ticker]
unique_members = len(set(t['member'] for t in ticker_trades))
        buy_percentage = len([t for t in ticker_trades if t['action'] == 'BUY']) / (len(ticker_trades) + 1)
return {
            'num_unique_members': unique_members,
            'buy_percentage': buy_percentage,
            'crowded': unique_members > 5 and buy_percentage > 0.7,
            'crowding_risk': 'When too many trade same direction, may indicate crowded exit'
        }