mcli-framework 7.1.0__py3-none-any.whl → 7.1.2__py3-none-any.whl

mcli/ml/dashboard/app_integrated.py

@@ -1,45 +1,57 @@
 """Integrated Streamlit dashboard for ML system with LSH daemon integration"""
 
-import streamlit as st
-import pandas as pd
-import plotly.express as px
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
 import asyncio
+import json
+import os
+import pickle
+import subprocess
 from datetime import datetime, timedelta
+from pathlib import Path
+
 import numpy as np
-from supabase import create_client, Client
-import os
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
 import requests
-import json
-from pathlib import Path
-import subprocess
-import pickle
+import streamlit as st
 from dotenv import load_dotenv
+from plotly.subplots import make_subplots
+from supabase import Client, create_client
 
 # Load environment variables from .env file
 load_dotenv()
 
 # Add ML pipeline imports
 try:
-    from mcli.ml.preprocessing import PoliticianTradingPreprocessor, MLDataPipeline
     from mcli.ml.models import get_model_by_id
+    from mcli.ml.preprocessing import MLDataPipeline, PoliticianTradingPreprocessor
+
     HAS_ML_PIPELINE = True
 except ImportError:
     HAS_ML_PIPELINE = False
     PoliticianTradingPreprocessor = None
     MLDataPipeline = None
 
+# Add prediction engine
+try:
+    from mcli.ml.predictions import PoliticianTradingPredictor
+
+    HAS_PREDICTOR = True
+except ImportError:
+    HAS_PREDICTOR = False
+    PoliticianTradingPredictor = None
+
 # Page config
 st.set_page_config(
     page_title="MCLI ML Dashboard - Integrated",
     page_icon="📊",
     layout="wide",
-    initial_sidebar_state="expanded"
+    initial_sidebar_state="expanded",
 )
 
 # Custom CSS
-st.markdown("""
+st.markdown(
+    """
 <style>
     .metric-card {
         background-color: #f0f2f6;
@@ -62,7 +74,9 @@ st.markdown("""
         border-radius: 0.25rem;
     }
 </style>
-""", unsafe_allow_html=True)
+""",
+    unsafe_allow_html=True,
+)
 
 
 @st.cache_resource
@@ -72,7 +86,9 @@ def get_supabase_client() -> Client:
     key = os.getenv("SUPABASE_KEY", "")
 
     if not url or not key:
-        st.warning("⚠️ Supabase credentials not found. Set SUPABASE_URL and SUPABASE_KEY environment variables.")
+        st.warning(
+            "⚠️ Supabase credentials not found. Set SUPABASE_URL and SUPABASE_KEY environment variables."
+        )
         return None
 
     return create_client(url, key)
@@ -94,6 +110,14 @@ def get_ml_pipeline():
     return None
 
 
+@st.cache_resource
+def get_predictor():
+    """Get prediction engine instance"""
+    if HAS_PREDICTOR and PoliticianTradingPredictor:
+        return PoliticianTradingPredictor()
+    return None
+
+
 def check_lsh_daemon():
     """Check if LSH daemon is running"""
     try:
@@ -112,7 +136,7 @@ def get_lsh_jobs():
         # Read from LSH log file
         log_path = Path("/tmp/lsh-job-daemon-lefv.log")
         if log_path.exists():
-            with open(log_path, 'r') as f:
+            with open(log_path, "r") as f:
                 lines = f.readlines()[-100:]  # Last 100 lines
 
             jobs = []
@@ -121,14 +145,20 @@ def get_lsh_jobs():
                     # Parse job info from log
                     parts = line.strip().split("|")
                     if len(parts) >= 3:
-                        jobs.append({
-                            'timestamp': parts[0].strip(),
-                            'status': 'completed' if 'Completed' in line else 'running',
-                            'job_name': parts[2].strip() if len(parts) > 2 else 'Unknown'
-                        })
+                        jobs.append(
+                            {
+                                "timestamp": parts[0].strip(),
+                                "status": "completed" if "Completed" in line else "running",
+                                "job_name": parts[2].strip() if len(parts) > 2 else "Unknown",
+                            }
+                        )
 
             return pd.DataFrame(jobs)
-    except:
+        else:
+            # Log file doesn't exist - return empty DataFrame
+            return pd.DataFrame()
+    except Exception as e:
+        # On any error, return empty DataFrame
         return pd.DataFrame()
 
 
@@ -142,7 +172,10 @@ def run_ml_pipeline(df_disclosures):
         # 1. Preprocess data
         preprocessor = get_preprocessor()
         if preprocessor:
-            processed_data = preprocessor.preprocess(df_disclosures)
+            try:
+                processed_data = preprocessor.preprocess(df_disclosures)
+            except:
+                processed_data = df_disclosures
         else:
             # Use raw data if preprocessor not available
             processed_data = df_disclosures
@@ -150,26 +183,61 @@ def run_ml_pipeline(df_disclosures):
         # 2. Feature engineering (using ML pipeline if available)
         ml_pipeline = get_ml_pipeline()
         if ml_pipeline:
-            features = ml_pipeline.transform(processed_data)
+            try:
+                features = ml_pipeline.transform(processed_data)
+            except:
+                features = processed_data
         else:
             features = processed_data
 
-        # 3. Generate predictions (mock for now, replace with actual model)
-        predictions = pd.DataFrame({
-            'ticker': processed_data['ticker_symbol'].unique()[:10] if 'ticker_symbol' in processed_data else [],
-            'predicted_return': np.random.uniform(-0.05, 0.05, min(10, len(processed_data['ticker_symbol'].unique())) if 'ticker_symbol' in processed_data else 0),
-            'confidence': np.random.uniform(0.6, 0.95, min(10, len(processed_data['ticker_symbol'].unique())) if 'ticker_symbol' in processed_data else 0),
-            'risk_score': np.random.uniform(0.1, 0.9, min(10, len(processed_data['ticker_symbol'].unique())) if 'ticker_symbol' in processed_data else 0),
-            'recommendation': np.random.choice(['BUY', 'HOLD', 'SELL'], min(10, len(processed_data['ticker_symbol'].unique())) if 'ticker_symbol' in processed_data else 0)
-        })
+        # 3. Generate predictions using real prediction engine
+        predictor = get_predictor()
+        if predictor and HAS_PREDICTOR:
+            try:
+                predictions = predictor.generate_predictions(df_disclosures)
+            except Exception as pred_error:
+                st.warning(f"Prediction engine error: {pred_error}. Using fallback predictions.")
+                predictions = _generate_fallback_predictions(processed_data)
+        else:
+            predictions = _generate_fallback_predictions(processed_data)
 
         return processed_data, features, predictions
     except Exception as e:
         st.error(f"Pipeline error: {e}")
+        import traceback
+
+        with st.expander("See error details"):
+            st.code(traceback.format_exc())
         return None, None, None
 
 
-@st.cache_data(ttl=30)
+def _generate_fallback_predictions(processed_data):
+    """Generate basic predictions when predictor is unavailable"""
+    if processed_data.empty:
+        return pd.DataFrame()
+
+    tickers = (
+        processed_data["ticker_symbol"].unique()[:10] if "ticker_symbol" in processed_data else []
+    )
+    n_tickers = len(tickers)
+
+    if n_tickers == 0:
+        return pd.DataFrame()
+
+    return pd.DataFrame(
+        {
+            "ticker": tickers,
+            "predicted_return": np.random.uniform(-0.05, 0.05, n_tickers),
+            "confidence": np.random.uniform(0.5, 0.8, n_tickers),
+            "risk_score": np.random.uniform(0.3, 0.7, n_tickers),
+            "recommendation": np.random.choice(["BUY", "HOLD", "SELL"], n_tickers),
+            "trade_count": np.random.randint(1, 10, n_tickers),
+            "signal_strength": np.random.uniform(0.3, 0.9, n_tickers),
+        }
+    )
+
+
+@st.cache_data(ttl=30, hash_funcs={pd.DataFrame: lambda x: x.to_json()})
 def get_politicians_data():
     """Get politicians data from Supabase"""
     client = get_supabase_client()
@@ -178,13 +246,21 @@ def get_politicians_data():
 
     try:
         response = client.table("politicians").select("*").execute()
-        return pd.DataFrame(response.data)
+        df = pd.DataFrame(response.data)
+        # Convert any dict/list columns to JSON strings to avoid hashing issues
+        for col in df.columns:
+            if df[col].dtype == "object":
+                if any(isinstance(x, (dict, list)) for x in df[col].dropna()):
+                    df[col] = df[col].apply(
+                        lambda x: json.dumps(x) if isinstance(x, (dict, list)) else x
+                    )
+        return df
     except Exception as e:
         st.error(f"Error fetching politicians: {e}")
         return pd.DataFrame()
 
 
-@st.cache_data(ttl=30)
+@st.cache_data(ttl=30, hash_funcs={pd.DataFrame: lambda x: x.to_json()})
 def get_disclosures_data():
     """Get trading disclosures from Supabase"""
     client = get_supabase_client()
@@ -192,8 +268,22 @@ def get_disclosures_data():
         return pd.DataFrame()
 
     try:
-        response = client.table("trading_disclosures").select("*").order("disclosure_date", desc=True).limit(1000).execute()
-        return pd.DataFrame(response.data)
+        response = (
+            client.table("trading_disclosures")
+            .select("*")
+            .order("disclosure_date", desc=True)
+            .limit(1000)
+            .execute()
+        )
+        df = pd.DataFrame(response.data)
+        # Convert any dict/list columns to JSON strings to avoid hashing issues
+        for col in df.columns:
+            if df[col].dtype == "object":
+                if any(isinstance(x, (dict, list)) for x in df[col].dropna()):
+                    df[col] = df[col].apply(
+                        lambda x: json.dumps(x) if isinstance(x, (dict, list)) else x
+                    )
+        return df
     except Exception as e:
         st.error(f"Error fetching disclosures: {e}")
         return pd.DataFrame()
@@ -211,17 +301,19 @@ def get_model_metrics():
     for model_file in model_dir.glob("*.pt"):
         try:
             # Load model metadata
-            metadata_file = model_file.with_suffix('.json')
+            metadata_file = model_file.with_suffix(".json")
             if metadata_file.exists():
-                with open(metadata_file, 'r') as f:
+                with open(metadata_file, "r") as f:
                     metadata = json.load(f)
-                    metrics.append({
-                        'model_name': model_file.stem,
-                        'accuracy': metadata.get('accuracy', 0),
-                        'sharpe_ratio': metadata.get('sharpe_ratio', 0),
-                        'created_at': metadata.get('created_at', ''),
-                        'status': 'deployed'
-                    })
+                    metrics.append(
+                        {
+                            "model_name": model_file.stem,
+                            "accuracy": metadata.get("accuracy", 0),
+                            "sharpe_ratio": metadata.get("sharpe_ratio", 0),
+                            "created_at": metadata.get("created_at", ""),
+                            "status": "deployed",
+                        }
+                    )
         except:
             continue
 
@@ -239,8 +331,15 @@ def main():
     st.sidebar.title("Navigation")
     page = st.sidebar.selectbox(
         "Choose a page",
-        ["Pipeline Overview", "ML Processing", "Model Performance", "Predictions", "LSH Jobs", "System Health"],
-        index=0  # Default to Pipeline Overview
+        [
+            "Pipeline Overview",
+            "ML Processing",
+            "Model Performance",
+            "Predictions",
+            "LSH Jobs",
+            "System Health",
+        ],
+        index=0,  # Default to Pipeline Overview
     )
 
     # Auto-refresh toggle (default off to prevent blocking)
@@ -248,6 +347,7 @@ def main():
     if auto_refresh:
         try:
             from streamlit_autorefresh import st_autorefresh
+
             st_autorefresh(interval=30000, key="data_refresh")
         except ImportError:
             st.sidebar.warning("⚠️ Auto-refresh requires streamlit-autorefresh package")
@@ -284,6 +384,7 @@ def main():
     except Exception as e:
         st.error(f"❌ Error loading page '{page}': {e}")
         import traceback
+
         with st.expander("See error details"):
             st.code(traceback.format_exc())
 
@@ -295,13 +396,15 @@ def show_pipeline_overview():
     # Check Supabase connection
     if not get_supabase_client():
         st.warning("⚠️ **Supabase not configured**")
-        st.info("""
+        st.info(
+            """
         To connect to Supabase, set these environment variables:
         - `SUPABASE_URL`: Your Supabase project URL
         - `SUPABASE_KEY`: Your Supabase API key
 
         The dashboard will show demo data until configured.
-        """)
+        """
+        )
 
     # Get data
     politicians = get_politicians_data()
@@ -313,9 +416,7 @@ def show_pipeline_overview():
 
     with col1:
         st.metric(
-            label="Data Sources",
-            value=len(politicians),
-            delta=f"{len(disclosures)} disclosures"
+            label="Data Sources", value=len(politicians), delta=f"{len(disclosures)} disclosures"
         )
 
     with col2:
@@ -336,23 +437,19 @@ def show_pipeline_overview():
         st.metric(
             label="Features Extracted",
             value=feature_count,
-            delta="Raw data" if not preprocessor else "After preprocessing"
+            delta="Raw data" if not preprocessor else "After preprocessing",
         )
 
     with col3:
         model_metrics = get_model_metrics()
-        st.metric(
-            label="Models Deployed",
-            value=len(model_metrics),
-            delta="Active models"
-        )
+        st.metric(label="Models Deployed", value=len(model_metrics), delta="Active models")
 
     with col4:
-        active_jobs = len(lsh_jobs[lsh_jobs['status'] == 'running']) if not lsh_jobs.empty else 0
+        active_jobs = len(lsh_jobs[lsh_jobs["status"] == "running"]) if not lsh_jobs.empty else 0
         st.metric(
             label="LSH Active Jobs",
             value=active_jobs,
-            delta=f"{len(lsh_jobs)} total" if not lsh_jobs.empty else "0 total"
+            delta=f"{len(lsh_jobs)} total" if not lsh_jobs.empty else "0 total",
         )
 
     # Pipeline flow diagram
@@ -364,7 +461,7 @@ def show_pipeline_overview():
         "3. Feature Engineering": "Technical indicators, sentiment, patterns",
         "4. Model Training": "Ensemble models (LSTM, Transformer, CNN)",
         "5. Predictions": "Return forecasts, risk scores, recommendations",
-        "6. Monitoring": "LSH daemon tracks performance"
+        "6. Monitoring": "LSH daemon tracks performance",
     }
 
     for step, description in pipeline_steps.items():
@@ -375,9 +472,11 @@ def show_pipeline_overview():
 
     if not lsh_jobs.empty:
         # Filter for ML-related jobs
-        ml_jobs = lsh_jobs[lsh_jobs['job_name'].str.contains('ml|model|train|predict', case=False, na=False)]
+        ml_jobs = lsh_jobs[
+            lsh_jobs["job_name"].str.contains("ml|model|train|predict", case=False, na=False)
+        ]
         if not ml_jobs.empty:
-            st.dataframe(ml_jobs.head(10), use_container_width=True)
+            st.dataframe(ml_jobs.head(10), width="stretch")
         else:
             st.info("No ML pipeline jobs found in LSH logs")
     else:
@@ -401,17 +500,20 @@ def show_ml_processing():
 
             with tabs[0]:
                 st.subheader("Raw Disclosure Data")
-                st.dataframe(disclosures.head(100), use_container_width=True)
+                st.dataframe(disclosures.head(100), width="stretch")
                 st.metric("Total Records", len(disclosures))
 
             with tabs[1]:
                 st.subheader("Preprocessed Data")
-                st.dataframe(processed_data.head(100), use_container_width=True)
+                st.dataframe(processed_data.head(100), width="stretch")
 
                 # Data quality metrics
                 col1, col2, col3 = st.columns(3)
                 with col1:
-                    missing_pct = (processed_data.isnull().sum().sum() / (len(processed_data) * len(processed_data.columns))) * 100
+                    missing_pct = (
+                        processed_data.isnull().sum().sum()
+                        / (len(processed_data) * len(processed_data.columns))
+                    ) * 100
                     st.metric("Data Completeness", f"{100-missing_pct:.1f}%")
                 with col2:
                     st.metric("Features", len(processed_data.columns))
@@ -422,16 +524,25 @@ def show_ml_processing():
                 st.subheader("Engineered Features")
                 if features is not None:
                     # Show feature importance
-                    feature_importance = pd.DataFrame({
-                        'feature': features.columns[:20],
-                        'importance': np.random.uniform(0.1, 1.0, min(20, len(features.columns)))
-                    }).sort_values('importance', ascending=False)
+                    feature_importance = pd.DataFrame(
+                        {
+                            "feature": features.columns[:20],
+                            "importance": np.random.uniform(
+                                0.1, 1.0, min(20, len(features.columns))
+                            ),
+                        }
+                    ).sort_values("importance", ascending=False)
 
-                    fig = px.bar(feature_importance, x='importance', y='feature', orientation='h',
-                               title="Top 20 Feature Importance")
-                    st.plotly_chart(fig, use_container_width=True)
+                    fig = px.bar(
+                        feature_importance,
+                        x="importance",
+                        y="feature",
+                        orientation="h",
+                        title="Top 20 Feature Importance",
+                    )
+                    st.plotly_chart(fig, width="stretch")
 
-                    st.dataframe(features.head(100), use_container_width=True)
+                    st.dataframe(features.head(100), width="stretch")
 
             with tabs[3]:
                 st.subheader("Model Predictions")
@@ -441,23 +552,30 @@ def show_ml_processing():
 
                     with col1:
                         # Recommendation distribution
-                        if 'recommendation' in predictions:
-                            rec_dist = predictions['recommendation'].value_counts()
-                            fig = px.pie(values=rec_dist.values, names=rec_dist.index,
-                                       title="Recommendation Distribution")
-                            st.plotly_chart(fig, use_container_width=True)
+                        if "recommendation" in predictions:
+                            rec_dist = predictions["recommendation"].value_counts()
+                            fig = px.pie(
+                                values=rec_dist.values,
+                                names=rec_dist.index,
+                                title="Recommendation Distribution",
+                            )
+                            st.plotly_chart(fig, width="stretch")
 
                     with col2:
                         # Confidence distribution
-                        if 'confidence' in predictions:
-                            fig = px.histogram(predictions, x='confidence', nbins=20,
-                                             title="Prediction Confidence Distribution")
-                            st.plotly_chart(fig, use_container_width=True)
+                        if "confidence" in predictions:
+                            fig = px.histogram(
+                                predictions,
+                                x="confidence",
+                                nbins=20,
+                                title="Prediction Confidence Distribution",
+                            )
+                            st.plotly_chart(fig, width="stretch")
 
                     # Top predictions
                     st.subheader("Top Investment Opportunities")
-                    top_predictions = predictions.nlargest(10, 'predicted_return')
-                    st.dataframe(top_predictions, use_container_width=True)
+                    top_predictions = predictions.nlargest(10, "predicted_return")
+                    st.dataframe(top_predictions, width="stretch")
         else:
             st.error("Failed to process data through pipeline")
     else:
@@ -475,41 +593,44 @@ def show_model_performance():
         col1, col2, col3 = st.columns(3)
 
         with col1:
-            avg_accuracy = model_metrics['accuracy'].mean()
+            avg_accuracy = model_metrics["accuracy"].mean()
             st.metric("Average Accuracy", f"{avg_accuracy:.2%}")
 
         with col2:
-            avg_sharpe = model_metrics['sharpe_ratio'].mean()
+            avg_sharpe = model_metrics["sharpe_ratio"].mean()
             st.metric("Average Sharpe Ratio", f"{avg_sharpe:.2f}")
 
         with col3:
-            deployed_count = len(model_metrics[model_metrics['status'] == 'deployed'])
+            deployed_count = len(model_metrics[model_metrics["status"] == "deployed"])
             st.metric("Deployed Models", deployed_count)
 
         # Model comparison
         st.subheader("Model Comparison")
 
         fig = make_subplots(
-            rows=1, cols=2,
-            subplot_titles=("Accuracy Comparison", "Sharpe Ratio Comparison")
+            rows=1, cols=2, subplot_titles=("Accuracy Comparison", "Sharpe Ratio Comparison")
         )
 
         fig.add_trace(
-            go.Bar(x=model_metrics['model_name'], y=model_metrics['accuracy'], name='Accuracy'),
-            row=1, col=1
+            go.Bar(x=model_metrics["model_name"], y=model_metrics["accuracy"], name="Accuracy"),
+            row=1,
+            col=1,
         )
 
         fig.add_trace(
-            go.Bar(x=model_metrics['model_name'], y=model_metrics['sharpe_ratio'], name='Sharpe Ratio'),
-            row=1, col=2
+            go.Bar(
+                x=model_metrics["model_name"], y=model_metrics["sharpe_ratio"], name="Sharpe Ratio"
+            ),
+            row=1,
+            col=2,
         )
 
         fig.update_layout(height=400, showlegend=False)
-        st.plotly_chart(fig, use_container_width=True)
+        st.plotly_chart(fig, width="stretch")
 
         # Model details table
         st.subheader("Model Details")
-        st.dataframe(model_metrics, use_container_width=True)
+        st.dataframe(model_metrics, width="stretch")
     else:
         st.info("No trained models found. Run the training pipeline to generate models.")
 
@@ -540,7 +661,11 @@ def show_predictions():
             with col2:
                 recommendation_filter = st.selectbox(
                     "Recommendation",
-                    ["All"] + list(predictions['recommendation'].unique()) if 'recommendation' in predictions else ["All"]
+                    (
+                        ["All"] + list(predictions["recommendation"].unique())
+                        if "recommendation" in predictions
+                        else ["All"]
+                    ),
                 )
 
             with col3:
@@ -548,10 +673,14 @@ def show_predictions():
 
             # Apply filters
             filtered_predictions = predictions.copy()
-            if 'confidence' in filtered_predictions:
-                filtered_predictions = filtered_predictions[filtered_predictions['confidence'] >= min_confidence]
-            if recommendation_filter != "All" and 'recommendation' in filtered_predictions:
-                filtered_predictions = filtered_predictions[filtered_predictions['recommendation'] == recommendation_filter]
+            if "confidence" in filtered_predictions:
+                filtered_predictions = filtered_predictions[
+                    filtered_predictions["confidence"] >= min_confidence
+                ]
+            if recommendation_filter != "All" and "recommendation" in filtered_predictions:
+                filtered_predictions = filtered_predictions[
+                    filtered_predictions["recommendation"] == recommendation_filter
+                ]
 
             # Sort
             if sort_by in filtered_predictions.columns:
@@ -568,21 +697,21 @@ def show_predictions():
                         st.markdown(f"**{pred.get('ticker', 'N/A')}**")
 
                     with col2:
-                        return_val = pred.get('predicted_return', 0)
+                        return_val = pred.get("predicted_return", 0)
                         color = "green" if return_val > 0 else "red"
                         st.markdown(f"Return: :{color}[{return_val:.2%}]")
 
                     with col3:
-                        conf = pred.get('confidence', 0)
+                        conf = pred.get("confidence", 0)
                         st.progress(conf, text=f"Conf: {conf:.0%}")
 
                     with col4:
-                        risk = pred.get('risk_score', 0)
+                        risk = pred.get("risk_score", 0)
                         risk_color = "red" if risk > 0.7 else "orange" if risk > 0.4 else "green"
                         st.markdown(f"Risk: :{risk_color}[{risk:.2f}]")
 
                     with col5:
-                        rec = pred.get('recommendation', 'N/A')
+                        rec = pred.get("recommendation", "N/A")
                         rec_color = {"BUY": "green", "SELL": "red", "HOLD": "gray"}.get(rec, "gray")
                         st.markdown(f":{rec_color}[**{rec}**]")
 
@@ -595,33 +724,33 @@ def show_predictions():
                 # Risk-return scatter
                 fig = px.scatter(
                     filtered_predictions,
-                    x='risk_score' if 'risk_score' in filtered_predictions else None,
-                    y='predicted_return' if 'predicted_return' in filtered_predictions else None,
-                    color='recommendation' if 'recommendation' in filtered_predictions else None,
-                    size='confidence' if 'confidence' in filtered_predictions else None,
-                    hover_data=['ticker'] if 'ticker' in filtered_predictions else None,
-                    title="Risk-Return Analysis"
+                    x="risk_score" if "risk_score" in filtered_predictions else None,
+                    y="predicted_return" if "predicted_return" in filtered_predictions else None,
+                    color="recommendation" if "recommendation" in filtered_predictions else None,
+                    size="confidence" if "confidence" in filtered_predictions else None,
+                    hover_data=["ticker"] if "ticker" in filtered_predictions else None,
+                    title="Risk-Return Analysis",
                 )
-                st.plotly_chart(fig, use_container_width=True)
+                st.plotly_chart(fig, width="stretch")
 
             with col2:
                 # Top movers
-                if 'predicted_return' in filtered_predictions and 'ticker' in filtered_predictions:
-                    top_gainers = filtered_predictions.nlargest(5, 'predicted_return')
-                    top_losers = filtered_predictions.nsmallest(5, 'predicted_return')
+                if "predicted_return" in filtered_predictions and "ticker" in filtered_predictions:
+                    top_gainers = filtered_predictions.nlargest(5, "predicted_return")
+                    top_losers = filtered_predictions.nsmallest(5, "predicted_return")
 
                     movers_data = pd.concat([top_gainers, top_losers])
 
                     fig = px.bar(
                         movers_data,
-                        x='predicted_return',
-                        y='ticker',
-                        orientation='h',
-                        color='predicted_return',
-                        color_continuous_scale='RdYlGn',
-                        title="Top Movers (Predicted)"
+                        x="predicted_return",
+                        y="ticker",
+                        orientation="h",
+                        color="predicted_return",
+                        color_continuous_scale="RdYlGn",
+                        title="Top Movers (Predicted)",
                     )
-                    st.plotly_chart(fig, use_container_width=True)
+                    st.plotly_chart(fig, width="stretch")
         else:
             st.warning("No predictions available. Check if the ML pipeline is running correctly.")
     else:
@@ -652,33 +781,33 @@ def show_lsh_jobs():
             st.metric("Total Jobs", total_jobs)
 
         with col2:
-            running_jobs = len(lsh_jobs[lsh_jobs['status'] == 'running'])
+            running_jobs = len(lsh_jobs[lsh_jobs["status"] == "running"])
             st.metric("Running Jobs", running_jobs)
 
         with col3:
-            completed_jobs = len(lsh_jobs[lsh_jobs['status'] == 'completed'])
+            completed_jobs = len(lsh_jobs[lsh_jobs["status"] == "completed"])
             success_rate = (completed_jobs / total_jobs * 100) if total_jobs > 0 else 0
             st.metric("Success Rate", f"{success_rate:.1f}%")
 
         # Recent jobs
         st.subheader("Recent Jobs")
-        st.dataframe(lsh_jobs.head(20), use_container_width=True)
+        st.dataframe(lsh_jobs.head(20), width="stretch")
 
         # Job timeline
-        if 'timestamp' in lsh_jobs:
+        if "timestamp" in lsh_jobs:
             try:
-                lsh_jobs['timestamp'] = pd.to_datetime(lsh_jobs['timestamp'])
+                lsh_jobs["timestamp"] = pd.to_datetime(lsh_jobs["timestamp"])
 
                 # Group by hour
-                hourly_jobs = lsh_jobs.set_index('timestamp').resample('1H').size()
+                hourly_jobs = lsh_jobs.set_index("timestamp").resample("1H").size()
 
                 fig = px.line(
                     x=hourly_jobs.index,
                     y=hourly_jobs.values,
                     title="Job Executions Over Time",
-                    labels={'x': 'Time', 'y': 'Job Count'}
+                    labels={"x": "Time", "y": "Job Count"},
                 )
-                st.plotly_chart(fig, use_container_width=True)
+                st.plotly_chart(fig, width="stretch")
             except:
                 pass
     else:
@@ -686,7 +815,8 @@ def show_lsh_jobs():
 
         # Show how to start LSH daemon
         with st.expander("How to start LSH daemon"):
-            st.code("""
+            st.code(
+                """
 # Start LSH daemon
 lsh daemon start
 
@@ -695,7 +825,8 @@ LSH_API_ENABLED=true LSH_API_PORT=3030 lsh daemon start
 
 # Check status
 lsh daemon status
-            """)
+            """
+            )
 
 
 def show_system_health():
@@ -740,42 +871,42 @@ def show_system_health():
         "Feature Engineering": "✅ Available",
         "Model Training": "✅ Ready" if Path("models").exists() else "⚠️ No models",
         "Prediction Engine": "✅ Ready",
-        "Monitoring": "✅ Active" if check_lsh_daemon() else "⚠️ LSH not running"
+        "Monitoring": "✅ Active" if check_lsh_daemon() else "⚠️ LSH not running",
     }
 
-    status_df = pd.DataFrame(
-        list(components.items()),
-        columns=["Component", "Status"]
-    )
+    status_df = pd.DataFrame(list(components.items()), columns=["Component", "Status"])
 
-    st.dataframe(status_df, use_container_width=True)
+    st.dataframe(status_df, width="stretch")
 
     # Resource usage (mock data for now)
     st.subheader("Resource Usage")
 
-    fig = make_subplots(
-        rows=2, cols=1,
-        subplot_titles=("CPU Usage (%)", "Memory Usage (%)")
-    )
+    fig = make_subplots(rows=2, cols=1, subplot_titles=("CPU Usage (%)", "Memory Usage (%)"))
 
     # Generate sample time series
-    times = pd.date_range(start=datetime.now() - timedelta(hours=6), end=datetime.now(), freq='10min')
+    times = pd.date_range(
+        start=datetime.now() - timedelta(hours=6), end=datetime.now(), freq="10min"
+    )
     cpu_usage = np.random.normal(45, 10, len(times))
     memory_usage = np.random.normal(60, 15, len(times))
 
     fig.add_trace(
-        go.Scatter(x=times, y=np.clip(cpu_usage, 0, 100), name='CPU', line=dict(color='blue')),
-        row=1, col=1
+        go.Scatter(x=times, y=np.clip(cpu_usage, 0, 100), name="CPU", line=dict(color="blue")),
+        row=1,
+        col=1,
     )
 
     fig.add_trace(
-        go.Scatter(x=times, y=np.clip(memory_usage, 0, 100), name='Memory', line=dict(color='green')),
-        row=2, col=1
+        go.Scatter(
+            x=times, y=np.clip(memory_usage, 0, 100), name="Memory", line=dict(color="green")
+        ),
+        row=2,
+        col=1,
     )
 
     fig.update_layout(height=500, showlegend=False)
-    st.plotly_chart(fig, use_container_width=True)
+    st.plotly_chart(fig, width="stretch")
 
 
-if __name__ == "__main__":
-    main()
+# Run the main dashboard function
+main()