mcli-framework 7.6.0__py3-none-any.whl → 7.6.1__py3-none-any.whl

mcli/ml/dashboard/pages/predictions_enhanced.py

@@ -1,55 +1,61 @@
 """Enhanced Predictions Dashboard with Interactive Features - REAL DATA"""
 
-import streamlit as st
-import pandas as pd
+import os
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional
+
 import numpy as np
+import pandas as pd
 import plotly.express as px
 import plotly.graph_objects as go
+import streamlit as st
 from plotly.subplots import make_subplots
-from datetime import datetime, timedelta
-from typing import Optional, Dict, List
-import os
 
 # Import components
 try:
-    from ..components.metrics import display_kpi_row, display_status_badge
     from ..components.charts import create_timeline_chart, render_chart
+    from ..components.metrics import display_kpi_row, display_status_badge
     from ..components.tables import display_filterable_dataframe, export_dataframe
 except ImportError:
     # Fallback for when imported outside package context
-    from components.metrics import display_kpi_row, display_status_badge
     from components.charts import create_timeline_chart, render_chart
+    from components.metrics import display_kpi_row, display_status_badge
     from components.tables import display_filterable_dataframe, export_dataframe
 
 # Import real data functions from utils
 try:
     from ..utils import (
-        get_supabase_client,
         get_disclosures_data,
         get_politician_names,
         get_politician_trading_history,
+        get_supabase_client,
     )
+
     HAS_REAL_DATA = True
 except ImportError:
     HAS_REAL_DATA = False
     st.warning("⚠️ Real data functions not available. Using fallback mode.")
 
+
 # Fallback functions for missing imports
 def run_ml_pipeline(df_disclosures):
     """Fallback ML pipeline function"""
     return df_disclosures
 
+
 def engineer_features(df):
     """Fallback feature engineering function"""
     return df
 
+
 def generate_production_prediction(df, features, trading_history):
     """Fallback prediction function"""
     import random
+
     return {
-        'predicted_return': random.uniform(-0.1, 0.1),
-        'confidence': random.uniform(0.5, 0.9),
-        'recommendation': random.choice(['BUY', 'SELL', 'HOLD'])
+        "predicted_return": random.uniform(-0.1, 0.1),
+        "confidence": random.uniform(0.5, 0.9),
+        "recommendation": random.choice(["BUY", "SELL", "HOLD"]),
     }
 
 
@@ -57,11 +63,39 @@ def generate_mock_predictions(num_predictions: int = 50) -> pd.DataFrame:
     """Generate mock prediction data for demonstration"""
     import random
 
-    tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'NVDA', 'TSLA', 'META', 'AMD', 'NFLX', 'INTC',
-               'JPM', 'BAC', 'WFC', 'GS', 'MS', 'V', 'MA', 'PYPL', 'SQ', 'COIN']
-    politicians = ['Nancy Pelosi', 'Paul Pelosi', 'Dan Crenshaw', 'Josh Gottheimer',
-                   'Susie Lee', 'Brian Higgins', 'Mark Green', 'Tommy Tuberville']
-    sectors = ['Technology', 'Finance', 'Healthcare', 'Energy', 'Consumer', 'Industrial']
+    tickers = [
+        "AAPL",
+        "MSFT",
+        "GOOGL",
+        "AMZN",
+        "NVDA",
+        "TSLA",
+        "META",
+        "AMD",
+        "NFLX",
+        "INTC",
+        "JPM",
+        "BAC",
+        "WFC",
+        "GS",
+        "MS",
+        "V",
+        "MA",
+        "PYPL",
+        "SQ",
+        "COIN",
+    ]
+    politicians = [
+        "Nancy Pelosi",
+        "Paul Pelosi",
+        "Dan Crenshaw",
+        "Josh Gottheimer",
+        "Susie Lee",
+        "Brian Higgins",
+        "Mark Green",
+        "Tommy Tuberville",
+    ]
+    sectors = ["Technology", "Finance", "Healthcare", "Energy", "Consumer", "Industrial"]
 
     predictions = []
     for i in range(num_predictions):
@@ -72,50 +106,54 @@ def generate_mock_predictions(num_predictions: int = 50) -> pd.DataFrame:
 
         # Recommendation logic
         if predicted_return > 0.10 and confidence > 0.7:
-            recommendation = 'BUY'
+            recommendation = "BUY"
         elif predicted_return < -0.05 and confidence > 0.7:
-            recommendation = 'SELL'
+            recommendation = "SELL"
         else:
-            recommendation = 'HOLD'
-
-        predictions.append({
-            'ticker': ticker,
-            'company_name': f'{ticker} Inc.',
-            'predicted_return': predicted_return,
-            'confidence': confidence,
-            'risk_score': risk_score,
-            'recommendation': recommendation,
-            'sector': random.choice(sectors),
-            'politician': random.choice(politicians),
-            'transaction_type': random.choice(['Purchase', 'Sale', 'Exchange']),
-            'transaction_date': (datetime.now() - timedelta(days=random.randint(0, 30))).date(),
-            'current_price': random.uniform(50, 500),
-            'target_price': random.uniform(50, 500),
-            'time_horizon_days': random.choice([30, 60, 90, 180]),
-            'historical_accuracy': random.uniform(0.6, 0.9),
-            'similar_trades_count': random.randint(1, 20)
-        })
+            recommendation = "HOLD"
+
+        predictions.append(
+            {
+                "ticker": ticker,
+                "company_name": f"{ticker} Inc.",
+                "predicted_return": predicted_return,
+                "confidence": confidence,
+                "risk_score": risk_score,
+                "recommendation": recommendation,
+                "sector": random.choice(sectors),
+                "politician": random.choice(politicians),
+                "transaction_type": random.choice(["Purchase", "Sale", "Exchange"]),
+                "transaction_date": (datetime.now() - timedelta(days=random.randint(0, 30))).date(),
+                "current_price": random.uniform(50, 500),
+                "target_price": random.uniform(50, 500),
+                "time_horizon_days": random.choice([30, 60, 90, 180]),
+                "historical_accuracy": random.uniform(0.6, 0.9),
+                "similar_trades_count": random.randint(1, 20),
+            }
+        )
 
     return pd.DataFrame(predictions)
 
 
 def generate_mock_historical_performance() -> pd.DataFrame:
     """Generate mock historical prediction performance"""
-    dates = pd.date_range(end=datetime.now(), periods=90, freq='D')
+    dates = pd.date_range(end=datetime.now(), periods=90, freq="D")
 
     performance = []
     for date in dates:
-        performance.append({
-            'date': date,
-            'accuracy': 0.65 + np.random.normal(0, 0.05),
-            'predictions_made': np.random.randint(10, 50),
-            'successful_predictions': np.random.randint(15, 40),
-            'avg_return': np.random.uniform(-0.02, 0.08),
-            'sharpe_ratio': np.random.uniform(0.5, 2.0)
-        })
+        performance.append(
+            {
+                "date": date,
+                "accuracy": 0.65 + np.random.normal(0, 0.05),
+                "predictions_made": np.random.randint(10, 50),
+                "successful_predictions": np.random.randint(15, 40),
+                "avg_return": np.random.uniform(-0.02, 0.08),
+                "sharpe_ratio": np.random.uniform(0.5, 2.0),
+            }
+        )
 
     df = pd.DataFrame(performance)
-    df['accuracy'] = df['accuracy'].clip(0.5, 0.95)
+    df["accuracy"] = df["accuracy"].clip(0.5, 0.95)
     return df
 
 
@@ -130,7 +168,9 @@ def get_real_predictions() -> pd.DataFrame:
         disclosures = get_disclosures_data()
 
         if disclosures.empty:
-            st.info("No disclosure data available. Click 'Run ML Pipeline' in sidebar to generate predictions.")
+            st.info(
+                "No disclosure data available. Click 'Run ML Pipeline' in sidebar to generate predictions."
+            )
             return generate_mock_predictions()
 
         # Run ML pipeline to generate predictions
@@ -138,17 +178,24 @@ def get_real_predictions() -> pd.DataFrame:
 
         if predictions is not None and not predictions.empty:
             # Ensure all required columns exist
-            required_cols = ['ticker', 'predicted_return', 'confidence', 'risk_score',
-                           'recommendation', 'sector', 'politician']
+            required_cols = [
+                "ticker",
+                "predicted_return",
+                "confidence",
+                "risk_score",
+                "recommendation",
+                "sector",
+                "politician",
+            ]
 
             for col in required_cols:
                 if col not in predictions.columns:
-                    if col == 'sector':
-                        predictions[col] = 'Technology'  # Default
-                    elif col == 'politician':
-                        predictions[col] = 'Unknown'
-                    elif col == 'ticker':
-                        predictions[col] = 'UNK'
+                    if col == "sector":
+                        predictions[col] = "Technology"  # Default
+                    elif col == "politician":
+                        predictions[col] = "Unknown"
+                    elif col == "ticker":
+                        predictions[col] = "UNK"
 
             return predictions
         else:
@@ -176,13 +223,15 @@ def show_predictions_enhanced():
             st.warning("🟡 Demo Mode")
 
     # Tabs for different views
-    tab1, tab2, tab3, tab4, tab5 = st.tabs([
-        "📊 Active Predictions",
-        "🎯 Prediction Generator",
-        "📈 Performance Tracker",
-        "👥 Politician Analysis",
-        "💼 Portfolio Builder"
-    ])
+    tab1, tab2, tab3, tab4, tab5 = st.tabs(
+        [
+            "📊 Active Predictions",
+            "🎯 Prediction Generator",
+            "📈 Performance Tracker",
+            "👥 Politician Analysis",
+            "💼 Portfolio Builder",
+        ]
+    )
 
     # Get REAL predictions data
     predictions_df = get_real_predictions()
@@ -210,18 +259,21 @@ def show_active_predictions(predictions_df: pd.DataFrame):
 
     # KPIs
     total_preds = len(predictions_df)
-    buy_preds = len(predictions_df[predictions_df['recommendation'] == 'BUY'])
-    sell_preds = len(predictions_df[predictions_df['recommendation'] == 'SELL'])
-    avg_confidence = predictions_df['confidence'].mean()
-    avg_return = predictions_df['predicted_return'].mean()
+    buy_preds = len(predictions_df[predictions_df["recommendation"] == "BUY"])
+    sell_preds = len(predictions_df[predictions_df["recommendation"] == "SELL"])
+    avg_confidence = predictions_df["confidence"].mean()
+    avg_return = predictions_df["predicted_return"].mean()
 
     metrics = {
         "Total Predictions": {"value": total_preds, "icon": "📊"},
         "BUY Signals": {"value": buy_preds, "icon": "📈", "delta": "+12"},
         "SELL Signals": {"value": sell_preds, "icon": "📉", "delta": "-3"},
         "Avg Confidence": {"value": f"{avg_confidence*100:.1f}%", "icon": "🎯"},
-        "Avg Return": {"value": f"{avg_return*100:+.1f}%", "icon": "💰",
-                      "delta_color": "normal" if avg_return > 0 else "inverse"}
+        "Avg Return": {
+            "value": f"{avg_return*100:+.1f}%",
+            "icon": "💰",
+            "delta_color": "normal" if avg_return > 0 else "inverse",
+        },
     }
 
     display_kpi_row(metrics, columns=5)
@@ -237,30 +289,28 @@ def show_active_predictions(predictions_df: pd.DataFrame):
 
     with col2:
         recommendation_filter = st.multiselect(
-            "Recommendation",
-            options=['BUY', 'SELL', 'HOLD'],
-            default=['BUY', 'SELL']
+            "Recommendation", options=["BUY", "SELL", "HOLD"], default=["BUY", "SELL"]
         )
 
     with col3:
         sector_filter = st.multiselect(
             "Sector",
-            options=predictions_df['sector'].unique().tolist(),
-            default=predictions_df['sector'].unique().tolist()
+            options=predictions_df["sector"].unique().tolist(),
+            default=predictions_df["sector"].unique().tolist(),
         )
 
     with col4:
         sort_by = st.selectbox(
             "Sort By",
             ["predicted_return", "confidence", "risk_score"],
-            format_func=lambda x: x.replace('_', ' ').title()
+            format_func=lambda x: x.replace("_", " ").title(),
         )
 
     # Apply filters
     filtered_df = predictions_df[
-        (predictions_df['confidence'] >= min_confidence) &
-        (predictions_df['recommendation'].isin(recommendation_filter)) &
-        (predictions_df['sector'].isin(sector_filter))
+        (predictions_df["confidence"] >= min_confidence)
+        & (predictions_df["recommendation"].isin(recommendation_filter))
+        & (predictions_df["sector"].isin(sector_filter))
     ].sort_values(sort_by, ascending=False)
 
     st.caption(f"Showing {len(filtered_df)} of {len(predictions_df)} predictions")
@@ -272,26 +322,26 @@ def show_active_predictions(predictions_df: pd.DataFrame):
         st.markdown("#### 📊 Risk-Return Analysis")
         fig = px.scatter(
             filtered_df,
-            x='risk_score',
-            y='predicted_return',
-            color='recommendation',
-            size='confidence',
-            hover_data=['ticker', 'sector'],
+            x="risk_score",
+            y="predicted_return",
+            color="recommendation",
+            size="confidence",
+            hover_data=["ticker", "sector"],
             title="Risk vs Expected Return",
-            labels={'risk_score': 'Risk Score', 'predicted_return': 'Expected Return'},
-            color_discrete_map={'BUY': '#10b981', 'SELL': '#ef4444', 'HOLD': '#6b7280'}
+            labels={"risk_score": "Risk Score", "predicted_return": "Expected Return"},
+            color_discrete_map={"BUY": "#10b981", "SELL": "#ef4444", "HOLD": "#6b7280"},
         )
         fig.update_layout(height=400)
         render_chart(fig)
 
     with col2:
         st.markdown("#### 🥧 Sector Distribution")
-        sector_counts = filtered_df['sector'].value_counts()
+        sector_counts = filtered_df["sector"].value_counts()
         fig = px.pie(
             values=sector_counts.values,
             names=sector_counts.index,
             title="Predictions by Sector",
-            hole=0.4
+            hole=0.4,
         )
         fig.update_layout(height=400)
         render_chart(fig)
@@ -299,8 +349,8 @@ def show_active_predictions(predictions_df: pd.DataFrame):
     # Top predictions
     st.markdown("### 🏆 Top Predictions")
 
-    top_buy = filtered_df[filtered_df['recommendation'] == 'BUY'].head(5)
-    top_sell = filtered_df[filtered_df['recommendation'] == 'SELL'].head(5)
+    top_buy = filtered_df[filtered_df["recommendation"] == "BUY"].head(5)
+    top_sell = filtered_df[filtered_df["recommendation"] == "SELL"].head(5)
 
     col1, col2 = st.columns(2)
 
@@ -317,9 +367,15 @@ def show_active_predictions(predictions_df: pd.DataFrame):
                 with cols[2]:
                     st.metric("Confidence", f"{row['confidence']*100:.0f}%")
                 with cols[3]:
-                    risk_color = "🟢" if row['risk_score'] < 0.4 else "🟡" if row['risk_score'] < 0.7 else "🔴"
+                    risk_color = (
+                        "🟢"
+                        if row["risk_score"] < 0.4
+                        else "🟡" if row["risk_score"] < 0.7 else "🔴"
+                    )
                     st.markdown(f"{risk_color} Risk: {row['risk_score']:.2f}")
-                st.caption(f"Based on {row['politician']}'s {row['transaction_type'].lower()} on {row['transaction_date']}")
+                st.caption(
+                    f"Based on {row['politician']}'s {row['transaction_type'].lower()} on {row['transaction_date']}"
+                )
                 st.divider()
 
     with col2:
@@ -335,9 +391,15 @@ def show_active_predictions(predictions_df: pd.DataFrame):
                 with cols[2]:
                     st.metric("Confidence", f"{row['confidence']*100:.0f}%")
                 with cols[3]:
-                    risk_color = "🟢" if row['risk_score'] < 0.4 else "🟡" if row['risk_score'] < 0.7 else "🔴"
+                    risk_color = (
+                        "🟢"
+                        if row["risk_score"] < 0.4
+                        else "🟡" if row["risk_score"] < 0.7 else "🔴"
+                    )
                     st.markdown(f"{risk_color} Risk: {row['risk_score']:.2f}")
-                st.caption(f"Based on {row['politician']}'s {row['transaction_type'].lower()} on {row['transaction_date']}")
+                st.caption(
+                    f"Based on {row['politician']}'s {row['transaction_type'].lower()} on {row['transaction_date']}"
+                )
                 st.divider()
 
     # Export
@@ -347,11 +409,18 @@ def show_active_predictions(predictions_df: pd.DataFrame):
     # Detailed table
     with st.expander("📋 View All Predictions (Table)"):
         st.dataframe(
-            filtered_df[[
-                'ticker', 'recommendation', 'predicted_return', 'confidence',
-                'risk_score', 'sector', 'politician'
-            ]],
-            width="stretch"
+            filtered_df[
+                [
+                    "ticker",
+                    "recommendation",
+                    "predicted_return",
+                    "confidence",
+                    "risk_score",
+                    "sector",
+                    "politician",
+                ]
+            ],
+            width="stretch",
         )
 
 
@@ -362,7 +431,7 @@ def show_prediction_generator():
     st.markdown("Get AI-powered predictions for specific stock/politician combinations")
 
     # Get REAL politician names from database
-    politician_list = ['Nancy Pelosi', 'Paul Pelosi', 'Dan Crenshaw']  # Fallback
+    politician_list = ["Nancy Pelosi", "Paul Pelosi", "Dan Crenshaw"]  # Fallback
     if HAS_REAL_DATA:
         try:
             politician_list = get_politician_names()
@@ -374,23 +443,26 @@ def show_prediction_generator():
     with col1:
         st.markdown("#### Stock Selection")
         ticker = st.text_input("Stock Ticker", placeholder="e.g., AAPL", value="NVDA")
-        sector = st.selectbox("Sector", ['Technology', 'Finance', 'Healthcare', 'Energy', 'Consumer', 'Industrial'])
+        sector = st.selectbox(
+            "Sector", ["Technology", "Finance", "Healthcare", "Energy", "Consumer", "Industrial"]
+        )
         current_price = st.number_input("Current Price ($)", min_value=1.0, value=450.0, step=10.0)
 
     with col2:
         st.markdown("#### Context")
-        politician = st.selectbox(
-            "Politician",
-            politician_list
+        politician = st.selectbox("Politician", politician_list)
+        transaction_type = st.selectbox("Transaction Type", ["Purchase", "Sale", "Exchange"])
+        transaction_amount = st.number_input(
+            "Transaction Amount ($)", min_value=1000, value=100000, step=10000
         )
-        transaction_type = st.selectbox("Transaction Type", ['Purchase', 'Sale', 'Exchange'])
-        transaction_amount = st.number_input("Transaction Amount ($)", min_value=1000, value=100000, step=10000)
 
     col1, col2, col3 = st.columns(3)
     with col1:
-        time_horizon = st.selectbox("Time Horizon", ['30 days', '60 days', '90 days', '180 days'])
+        time_horizon = st.selectbox("Time Horizon", ["30 days", "60 days", "90 days", "180 days"])
     with col2:
-        risk_tolerance = st.select_slider("Risk Tolerance", options=['Low', 'Medium', 'High'], value='Medium')
+        risk_tolerance = st.select_slider(
+            "Risk Tolerance", options=["Low", "Medium", "High"], value="Medium"
+        )
     with col3:
         use_historical = st.checkbox("Use Historical Patterns", value=True)
 
@@ -413,31 +485,43 @@ def show_prediction_generator():
                         market_cap="Large Cap",  # Could be fetched from API
                         sector=sector,
                         sentiment=0.2,  # Could be fetched from sentiment API
-                        volatility=0.3 if risk_tolerance == 'Low' else 0.5 if risk_tolerance == 'Medium' else 0.7,
-                        trading_history=trading_history
+                        volatility=(
+                            0.3
+                            if risk_tolerance == "Low"
+                            else 0.5 if risk_tolerance == "Medium" else 0.7
+                        ),
+                        trading_history=trading_history,
                     )
 
                     # Generate REAL prediction
                     prediction_result = generate_production_prediction(features)
 
-                    predicted_return = prediction_result['predicted_return']
-                    confidence = prediction_result['confidence']
-                    risk_score = prediction_result['risk_score']
+                    predicted_return = prediction_result["predicted_return"]
+                    confidence = prediction_result["confidence"]
+                    risk_score = prediction_result["risk_score"]
 
                     st.success("✅ Prediction Generated from Real Data & ML Model!")
 
                 except Exception as e:
                     st.warning(f"Could not use real model: {e}. Using demo prediction.")
                     # Fallback to demo
-                    predicted_return = np.random.uniform(0.05, 0.25) if transaction_type == 'Purchase' else np.random.uniform(-0.15, -0.05)
+                    predicted_return = (
+                        np.random.uniform(0.05, 0.25)
+                        if transaction_type == "Purchase"
+                        else np.random.uniform(-0.15, -0.05)
+                    )
                     confidence = np.random.uniform(0.7, 0.95)
-                    risk_score = {'Low': 0.3, 'Medium': 0.5, 'High': 0.7}[risk_tolerance]
+                    risk_score = {"Low": 0.3, "Medium": 0.5, "High": 0.7}[risk_tolerance]
             else:
                 # Demo mode
                 st.info("Using demo prediction (Supabase not connected)")
-                predicted_return = np.random.uniform(0.05, 0.25) if transaction_type == 'Purchase' else np.random.uniform(-0.15, -0.05)
+                predicted_return = (
+                    np.random.uniform(0.05, 0.25)
+                    if transaction_type == "Purchase"
+                    else np.random.uniform(-0.15, -0.05)
+                )
                 confidence = np.random.uniform(0.7, 0.95)
-                risk_score = {'Low': 0.3, 'Medium': 0.5, 'High': 0.7}[risk_tolerance]
+                risk_score = {"Low": 0.3, "Medium": 0.5, "High": 0.7}[risk_tolerance]
 
             st.success("✅ Prediction Generated!")
 
@@ -446,16 +530,26 @@ def show_prediction_generator():
 
             col1, col2, col3, col4 = st.columns(4)
             with col1:
-                st.metric("Predicted Return", f"{predicted_return*100:+.1f}%",
-                         delta=f"{predicted_return*transaction_amount:+,.0f}")
+                st.metric(
+                    "Predicted Return",
+                    f"{predicted_return*100:+.1f}%",
+                    delta=f"{predicted_return*transaction_amount:+,.0f}",
+                )
             with col2:
                 st.metric("Confidence", f"{confidence*100:.0f}%")
             with col3:
-                recommendation = 'BUY' if predicted_return > 0.1 else 'SELL' if predicted_return < -0.05 else 'HOLD'
+                recommendation = (
+                    "BUY"
+                    if predicted_return > 0.1
+                    else "SELL" if predicted_return < -0.05 else "HOLD"
+                )
                 st.metric("Recommendation", recommendation)
             with col4:
-                st.metric("Risk Score", f"{risk_score:.2f}",
-                         delta="Low" if risk_score < 0.4 else "High" if risk_score > 0.7 else "Medium")
+                st.metric(
+                    "Risk Score",
+                    f"{risk_score:.2f}",
+                    delta="Low" if risk_score < 0.4 else "High" if risk_score > 0.7 else "Medium",
+                )
 
             # Detailed analysis
             st.markdown("### 🔍 Detailed Analysis")
@@ -463,7 +557,8 @@ def show_prediction_generator():
             tab1, tab2, tab3 = st.tabs(["💡 Key Insights", "📈 Price Forecast", "⚠️ Risk Factors"])
 
             with tab1:
-                st.markdown(f"""
+                st.markdown(
+                    f"""
                 **Trading Pattern Analysis:**
                 - {politician} has a historical accuracy of **{np.random.uniform(0.65, 0.85):.0%}** on {sector} stocks
                 - Similar transactions by {politician} resulted in average returns of **{np.random.uniform(0.05, 0.20):.1%}**
@@ -473,12 +568,13 @@ def show_prediction_generator():
                 - Pattern match: {confidence*100:.0f}%
                 - Data recency: {np.random.uniform(0.7, 0.95)*100:.0f}%
                 - Market alignment: {np.random.uniform(0.6, 0.9)*100:.0f}%
-                """)
+                """
+                )
 
             with tab2:
                 # Price forecast chart
                 days = int(time_horizon.split()[0])
-                dates = pd.date_range(start=datetime.now(), periods=days, freq='D')
+                dates = pd.date_range(start=datetime.now(), periods=days, freq="D")
 
                 # Generate forecast
                 base_trend = predicted_return / days
@@ -491,45 +587,58 @@ def show_prediction_generator():
                 lower_bound = forecast_prices * 0.9
 
                 fig = go.Figure()
-                fig.add_trace(go.Scatter(
-                    x=dates, y=forecast_prices,
-                    mode='lines',
-                    name='Forecast',
-                    line=dict(color='#3b82f6', width=3)
-                ))
-                fig.add_trace(go.Scatter(
-                    x=dates, y=upper_bound,
-                    mode='lines',
-                    name='Upper Bound',
-                    line=dict(width=0),
-                    showlegend=False
-                ))
-                fig.add_trace(go.Scatter(
-                    x=dates, y=lower_bound,
-                    mode='lines',
-                    name='Lower Bound',
-                    fill='tonexty',
-                    line=dict(width=0),
-                    fillcolor='rgba(59, 130, 246, 0.2)',
-                    showlegend=True
-                ))
+                fig.add_trace(
+                    go.Scatter(
+                        x=dates,
+                        y=forecast_prices,
+                        mode="lines",
+                        name="Forecast",
+                        line=dict(color="#3b82f6", width=3),
+                    )
+                )
+                fig.add_trace(
+                    go.Scatter(
+                        x=dates,
+                        y=upper_bound,
+                        mode="lines",
+                        name="Upper Bound",
+                        line=dict(width=0),
+                        showlegend=False,
+                    )
+                )
+                fig.add_trace(
+                    go.Scatter(
+                        x=dates,
+                        y=lower_bound,
+                        mode="lines",
+                        name="Lower Bound",
+                        fill="tonexty",
+                        line=dict(width=0),
+                        fillcolor="rgba(59, 130, 246, 0.2)",
+                        showlegend=True,
+                    )
+                )
 
                 fig.update_layout(
                     title=f"{ticker} Price Forecast ({time_horizon})",
                     xaxis_title="Date",
                     yaxis_title="Price ($)",
                     height=400,
-                    hovermode='x unified'
+                    hovermode="x unified",
                 )
 
                 render_chart(fig)
 
                 target_price = forecast_prices[-1]
-                st.metric("Target Price", f"${target_price:.2f}",
-                         delta=f"{(target_price/current_price - 1)*100:+.1f}%")
+                st.metric(
+                    "Target Price",
+                    f"${target_price:.2f}",
+                    delta=f"{(target_price/current_price - 1)*100:+.1f}%",
+                )
 
             with tab3:
-                st.markdown(f"""
+                st.markdown(
+                    f"""
                 **Risk Assessment:**
 
                 🎯 **Overall Risk Level:** {risk_score:.2f}/1.00 ({'Low' if risk_score < 0.4 else 'High' if risk_score > 0.7 else 'Medium'})
@@ -545,7 +654,8 @@ def show_prediction_generator():
                 - Set stop-loss at {(1 - np.random.uniform(0.05, 0.15))*100:.1f}% of entry price
                 - Monitor for changes in trading patterns
                 - Review prediction after 30 days
-                """)
+                """
+                )
 
 
 def show_performance_tracker():
@@ -558,18 +668,18 @@ def show_performance_tracker():
     performance_df = generate_mock_historical_performance()
 
     # KPIs
-    recent_accuracy = performance_df.tail(30)['accuracy'].mean()
-    total_predictions = performance_df['predictions_made'].sum()
-    total_successful = performance_df['successful_predictions'].sum()
-    avg_return = performance_df['avg_return'].mean()
-    avg_sharpe = performance_df['sharpe_ratio'].mean()
+    recent_accuracy = performance_df.tail(30)["accuracy"].mean()
+    total_predictions = performance_df["predictions_made"].sum()
+    total_successful = performance_df["successful_predictions"].sum()
+    avg_return = performance_df["avg_return"].mean()
+    avg_sharpe = performance_df["sharpe_ratio"].mean()
 
     metrics = {
         "30-Day Accuracy": {"value": f"{recent_accuracy*100:.1f}%", "icon": "🎯", "delta": "+2.3%"},
         "Total Predictions": {"value": f"{total_predictions:,}", "icon": "📊"},
         "Successful": {"value": f"{total_successful:,}", "icon": "✅"},
         "Avg Return": {"value": f"{avg_return*100:+.1f}%", "icon": "💰"},
-        "Sharpe Ratio": {"value": f"{avg_sharpe:.2f}", "icon": "📈"}
+        "Sharpe Ratio": {"value": f"{avg_sharpe:.2f}", "icon": "📈"},
     }
 
     display_kpi_row(metrics, columns=5)
@@ -580,23 +690,27 @@ def show_performance_tracker():
     st.markdown("### 📊 Accuracy Trend")
 
     fig = go.Figure()
-    fig.add_trace(go.Scatter(
-        x=performance_df['date'],
-        y=performance_df['accuracy'] * 100,
-        mode='lines+markers',
-        name='Daily Accuracy',
-        line=dict(color='#10b981', width=2)
-    ))
+    fig.add_trace(
+        go.Scatter(
+            x=performance_df["date"],
+            y=performance_df["accuracy"] * 100,
+            mode="lines+markers",
+            name="Daily Accuracy",
+            line=dict(color="#10b981", width=2),
+        )
+    )
 
     # Add rolling average
-    rolling_avg = performance_df['accuracy'].rolling(window=7).mean() * 100
-    fig.add_trace(go.Scatter(
-        x=performance_df['date'],
-        y=rolling_avg,
-        mode='lines',
-        name='7-Day Average',
-        line=dict(color='#3b82f6', width=3, dash='dash')
-    ))
+    rolling_avg = performance_df["accuracy"].rolling(window=7).mean() * 100
+    fig.add_trace(
+        go.Scatter(
+            x=performance_df["date"],
+            y=rolling_avg,
+            mode="lines",
+            name="7-Day Average",
+            line=dict(color="#3b82f6", width=3, dash="dash"),
+        )
+    )
 
     # Target line
     fig.add_hline(y=70, line_dash="dot", line_color="red", annotation_text="Target: 70%")
@@ -606,7 +720,7 @@ def show_performance_tracker():
         xaxis_title="Date",
         yaxis_title="Accuracy (%)",
         height=400,
-        hovermode='x unified'
+        hovermode="x unified",
     )
 
     render_chart(fig)
@@ -624,7 +738,7 @@ def show_performance_tracker():
             x=returns * 100,
             nbins=50,
             title="Distribution of Predicted Returns",
-            labels={'x': 'Return (%)', 'y': 'Frequency'}
+            labels={"x": "Return (%)", "y": "Frequency"},
         )
         fig.add_vline(x=0, line_dash="dash", line_color="red")
         fig.update_layout(height=350)
@@ -633,23 +747,25 @@ def show_performance_tracker():
     with col2:
         st.markdown("### 📊 Win Rate by Recommendation")
 
-        win_rates = pd.DataFrame({
-            'Recommendation': ['BUY', 'SELL', 'HOLD'],
-            'Win Rate': [0.68, 0.62, 0.71],
-            'Count': [450, 280, 320]
-        })
+        win_rates = pd.DataFrame(
+            {
+                "Recommendation": ["BUY", "SELL", "HOLD"],
+                "Win Rate": [0.68, 0.62, 0.71],
+                "Count": [450, 280, 320],
+            }
+        )
 
         fig = px.bar(
             win_rates,
-            x='Recommendation',
-            y='Win Rate',
-            text='Win Rate',
+            x="Recommendation",
+            y="Win Rate",
+            text="Win Rate",
             title="Success Rate by Recommendation Type",
-            color='Win Rate',
-            color_continuous_scale='RdYlGn',
-            range_color=[0.5, 0.8]
+            color="Win Rate",
+            color_continuous_scale="RdYlGn",
+            range_color=[0.5, 0.8],
         )
-        fig.update_traces(texttemplate='%{text:.1%}', textposition='outside')
+        fig.update_traces(texttemplate="%{text:.1%}", textposition="outside")
         fig.update_layout(height=350)
         render_chart(fig)
 
@@ -661,14 +777,26 @@ def show_politician_analysis(predictions_df: pd.DataFrame):
     st.markdown("Analyze prediction patterns by politician trading activity")
 
     # Group by politician
-    politician_stats = predictions_df.groupby('politician').agg({
-        'ticker': 'count',
-        'predicted_return': 'mean',
-        'confidence': 'mean',
-        'risk_score': 'mean'
-    }).reset_index()
-    politician_stats.columns = ['Politician', 'Predictions', 'Avg Return', 'Avg Confidence', 'Avg Risk']
-    politician_stats = politician_stats.sort_values('Avg Return', ascending=False)
+    politician_stats = (
+        predictions_df.groupby("politician")
+        .agg(
+            {
+                "ticker": "count",
+                "predicted_return": "mean",
+                "confidence": "mean",
+                "risk_score": "mean",
+            }
+        )
+        .reset_index()
+    )
+    politician_stats.columns = [
+        "Politician",
+        "Predictions",
+        "Avg Return",
+        "Avg Confidence",
+        "Avg Risk",
+    ]
+    politician_stats = politician_stats.sort_values("Avg Return", ascending=False)
 
     # Top politicians
     col1, col2 = st.columns(2)
@@ -678,15 +806,15 @@ def show_politician_analysis(predictions_df: pd.DataFrame):
 
         fig = px.bar(
             politician_stats.head(5),
-            x='Avg Return',
-            y='Politician',
-            orientation='h',
+            x="Avg Return",
+            y="Politician",
+            orientation="h",
             title="Politicians with Highest Predicted Returns",
-            text='Avg Return',
-            color='Avg Return',
-            color_continuous_scale='RdYlGn'
+            text="Avg Return",
+            color="Avg Return",
+            color_continuous_scale="RdYlGn",
         )
-        fig.update_traces(texttemplate='%{text:.1%}', textposition='outside')
+        fig.update_traces(texttemplate="%{text:.1%}", textposition="outside")
         fig.update_layout(height=350)
         render_chart(fig)
 
@@ -695,10 +823,10 @@ def show_politician_analysis(predictions_df: pd.DataFrame):
 
         fig = px.pie(
             politician_stats,
-            values='Predictions',
-            names='Politician',
+            values="Predictions",
+            names="Politician",
             title="Prediction Distribution by Politician",
-            hole=0.4
+            hole=0.4,
         )
         fig.update_layout(height=350)
         render_chart(fig)
@@ -707,11 +835,10 @@ def show_politician_analysis(predictions_df: pd.DataFrame):
     st.markdown("### 🔍 Detailed Analysis")
 
     selected_politician = st.selectbox(
-        "Select Politician",
-        options=predictions_df['politician'].unique().tolist()
+        "Select Politician", options=predictions_df["politician"].unique().tolist()
     )
 
-    pol_data = predictions_df[predictions_df['politician'] == selected_politician]
+    pol_data = predictions_df[predictions_df["politician"] == selected_politician]
 
     col1, col2, col3, col4 = st.columns(4)
     with col1:
@@ -721,29 +848,30 @@ def show_politician_analysis(predictions_df: pd.DataFrame):
     with col3:
         st.metric("Avg Confidence", f"{pol_data['confidence'].mean()*100:.0f}%")
     with col4:
-        buy_rate = len(pol_data[pol_data['recommendation'] == 'BUY']) / len(pol_data) * 100
+        buy_rate = len(pol_data[pol_data["recommendation"] == "BUY"]) / len(pol_data) * 100
         st.metric("BUY Rate", f"{buy_rate:.0f}%")
 
     # Sector breakdown
     st.markdown(f"#### Sector Preferences - {selected_politician}")
 
-    sector_breakdown = pol_data.groupby('sector').agg({
-        'ticker': 'count',
-        'predicted_return': 'mean'
-    }).reset_index()
-    sector_breakdown.columns = ['Sector', 'Count', 'Avg Return']
+    sector_breakdown = (
+        pol_data.groupby("sector")
+        .agg({"ticker": "count", "predicted_return": "mean"})
+        .reset_index()
+    )
+    sector_breakdown.columns = ["Sector", "Count", "Avg Return"]
 
     fig = px.scatter(
         sector_breakdown,
-        x='Count',
-        y='Avg Return',
-        size='Count',
-        color='Sector',
+        x="Count",
+        y="Avg Return",
+        size="Count",
+        color="Sector",
         title=f"{selected_politician}'s Sector Performance",
-        labels={'Count': 'Number of Trades', 'Avg Return': 'Average Predicted Return'},
-        text='Sector'
+        labels={"Count": "Number of Trades", "Avg Return": "Average Predicted Return"},
+        text="Sector",
     )
-    fig.update_traces(textposition='top center')
+    fig.update_traces(textposition="top center")
     fig.update_layout(height=400)
     render_chart(fig)
 
@@ -761,68 +889,88 @@ def show_portfolio_builder(predictions_df: pd.DataFrame):
 
         portfolio_size = st.slider("Number of Stocks", 3, 15, 8)
         risk_preference = st.select_slider(
-            "Risk Preference",
-            options=['Conservative', 'Balanced', 'Aggressive'],
-            value='Balanced'
+            "Risk Preference", options=["Conservative", "Balanced", "Aggressive"], value="Balanced"
         )
         min_confidence = st.slider("Min Confidence", 0.5, 0.95, 0.7, 0.05)
-        total_capital = st.number_input("Total Capital ($)", min_value=1000, value=100000, step=10000)
+        total_capital = st.number_input(
+            "Total Capital ($)", min_value=1000, value=100000, step=10000
+        )
 
         if st.button("🎯 Build Portfolio", type="primary", width="stretch"):
-            st.session_state['portfolio_built'] = True
+            st.session_state["portfolio_built"] = True
 
     with col2:
-        if st.session_state.get('portfolio_built'):
+        if st.session_state.get("portfolio_built"):
             st.markdown("#### 🎉 Recommended Portfolio")
 
             # Filter and select stocks
-            risk_thresholds = {
-                'Conservative': 0.4,
-                'Balanced': 0.6,
-                'Aggressive': 0.8
-            }
+            risk_thresholds = {"Conservative": 0.4, "Balanced": 0.6, "Aggressive": 0.8}
 
             filtered = predictions_df[
-                (predictions_df['confidence'] >= min_confidence) &
-                (predictions_df['risk_score'] <= risk_thresholds[risk_preference]) &
-                (predictions_df['recommendation'] == 'BUY')
-            ].nlargest(portfolio_size, 'predicted_return')
+                (predictions_df["confidence"] >= min_confidence)
+                & (predictions_df["risk_score"] <= risk_thresholds[risk_preference])
+                & (predictions_df["recommendation"] == "BUY")
+            ].nlargest(portfolio_size, "predicted_return")
 
             if len(filtered) > 0:
                 # Calculate allocations
-                total_score = filtered['confidence'].sum()
-                filtered['allocation'] = filtered['confidence'] / total_score
-                filtered['investment'] = filtered['allocation'] * total_capital
+                total_score = filtered["confidence"].sum()
+                filtered["allocation"] = filtered["confidence"] / total_score
+                filtered["investment"] = filtered["allocation"] * total_capital
 
                 # Portfolio metrics
                 col_a, col_b, col_c, col_d = st.columns(4)
                 with col_a:
                     st.metric("Stocks", len(filtered))
                 with col_b:
-                    st.metric("Expected Return", f"{(filtered['predicted_return'] * filtered['allocation']).sum()*100:+.1f}%")
+                    st.metric(
+                        "Expected Return",
+                        f"{(filtered['predicted_return'] * filtered['allocation']).sum()*100:+.1f}%",
+                    )
                 with col_c:
                     st.metric("Avg Confidence", f"{filtered['confidence'].mean()*100:.0f}%")
                 with col_d:
-                    st.metric("Portfolio Risk", f"{(filtered['risk_score'] * filtered['allocation']).sum():.2f}")
+                    st.metric(
+                        "Portfolio Risk",
+                        f"{(filtered['risk_score'] * filtered['allocation']).sum():.2f}",
+                    )
 
                 # Allocation pie chart
                 fig = px.pie(
                     filtered,
-                    values='allocation',
-                    names='ticker',
+                    values="allocation",
+                    names="ticker",
                     title="Portfolio Allocation",
-                    hole=0.4
+                    hole=0.4,
                 )
                 fig.update_layout(height=350)
                 render_chart(fig)
 
                 # Detailed table
                 st.markdown("#### 📋 Portfolio Details")
-                portfolio_display = filtered[['ticker', 'sector', 'predicted_return', 'confidence', 'risk_score', 'allocation', 'investment']].copy()
-                portfolio_display['predicted_return'] = portfolio_display['predicted_return'].apply(lambda x: f"{x*100:+.1f}%")
-                portfolio_display['confidence'] = portfolio_display['confidence'].apply(lambda x: f"{x*100:.0f}%")
-                portfolio_display['allocation'] = portfolio_display['allocation'].apply(lambda x: f"{x*100:.1f}%")
-                portfolio_display['investment'] = portfolio_display['investment'].apply(lambda x: f"${x:,.0f}")
+                portfolio_display = filtered[
+                    [
+                        "ticker",
+                        "sector",
+                        "predicted_return",
+                        "confidence",
+                        "risk_score",
+                        "allocation",
+                        "investment",
+                    ]
+                ].copy()
+                portfolio_display["predicted_return"] = portfolio_display["predicted_return"].apply(
+                    lambda x: f"{x*100:+.1f}%"
+                )
+                portfolio_display["confidence"] = portfolio_display["confidence"].apply(
+                    lambda x: f"{x*100:.0f}%"
+                )
+                portfolio_display["allocation"] = portfolio_display["allocation"].apply(
+                    lambda x: f"{x*100:.1f}%"
+                )
+                portfolio_display["investment"] = portfolio_display["investment"].apply(
+                    lambda x: f"${x:,.0f}"
+                )
 
                 st.dataframe(portfolio_display, width="stretch")