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

mcli/ml/dashboard/app_supabase.py

@@ -42,18 +42,34 @@ st.markdown(
 
 @st.cache_resource
 def get_supabase_client() -> Client:
-    """Get Supabase client"""
-    url = os.getenv("SUPABASE_URL", "")
-    # Try both SUPABASE_KEY and SUPABASE_ANON_KEY
-    key = os.getenv("SUPABASE_KEY", "") or os.getenv("SUPABASE_ANON_KEY", "")
+    """Get Supabase client with Streamlit Cloud secrets support"""
+    # Try Streamlit secrets first (for Streamlit Cloud), then fall back to environment variables (for local dev)
+    try:
+        url = st.secrets.get("SUPABASE_URL", "")
+        key = st.secrets.get("SUPABASE_KEY", "") or st.secrets.get("SUPABASE_SERVICE_ROLE_KEY", "")
+    except (AttributeError, FileNotFoundError):
+        # Secrets not available, try environment variables
+        url = os.getenv("SUPABASE_URL", "")
+        key = os.getenv("SUPABASE_KEY", "") or os.getenv("SUPABASE_SERVICE_ROLE_KEY", "")
 
     if not url or not key:
         st.warning(
-            "⚠️ Supabase credentials not found. Set SUPABASE_URL and SUPABASE_ANON_KEY environment variables."
+            "⚠️ Supabase credentials not found. Configure SUPABASE_URL and SUPABASE_KEY in Streamlit Cloud secrets or environment variables."
         )
         return None
 
-    return create_client(url, key)
+    try:
+        client = create_client(url, key)
+        # Test connection
+        try:
+            client.table("politicians").select("id").limit(1).execute()
+            return client
+        except Exception as e:
+            st.error(f"❌ Supabase connection test failed: {e}")
+            return None
+    except Exception as e:
+        st.error(f"❌ Failed to create Supabase client: {e}")
+        return None
 
 
 @st.cache_data(ttl=30)
@@ -91,9 +107,18 @@ def get_disclosures_data():
             .limit(500)
             .execute()
         )
-        return pd.DataFrame(response.data)
+        df = pd.DataFrame(response.data)
+
+        # Convert datetime columns to proper datetime format
+        date_columns = ['transaction_date', 'disclosure_date', 'created_at', 'updated_at']
+        for col in date_columns:
+            if col in df.columns:
+                df[col] = pd.to_datetime(df[col], format='ISO8601', errors='coerce')
+
+        return df
     except Exception as e:
         st.error(f"Error fetching disclosures: {e}")
+        print(f"Error details: {e}")  # Debug output
         return pd.DataFrame()
 
 
@@ -330,7 +355,7 @@ def show_overview():
             fig = px.pie(
                 values=type_counts.values, names=type_counts.index, title="Transaction Types"
             )
-            st.plotly_chart(fig, use_container_width=True)
+            st.plotly_chart(fig, width="stretch", config={"responsive": True})
         else:
             st.info("No disclosure data available")
 
@@ -344,7 +369,7 @@ def show_overview():
                 orientation="h",
                 title="Most Traded Stocks",
             )
-            st.plotly_chart(fig, use_container_width=True)
+            st.plotly_chart(fig, width="stretch", config={"responsive": True})
         else:
             st.info("No ticker data available")
 
@@ -383,7 +408,7 @@ def show_politicians():
             filtered = filtered[filtered["is_active"] == True]
 
         # Display data
-        st.dataframe(filtered, use_container_width=True)
+        st.dataframe(filtered, width="stretch")
 
         # Stats
         col1, col2 = st.columns(2)
@@ -393,14 +418,14 @@ def show_politicians():
                 fig = px.pie(
                     values=party_dist.values, names=party_dist.index, title="Party Distribution"
                 )
-                st.plotly_chart(fig, use_container_width=True)
+                st.plotly_chart(fig, width="stretch", config={"responsive": True})
         with col2:
             if "state" in filtered:
                 state_dist = filtered["state"].value_counts().head(10)
                 fig = px.bar(
                     x=state_dist.values, y=state_dist.index, orientation="h", title="Top States"
                 )
-                st.plotly_chart(fig, use_container_width=True)
+                st.plotly_chart(fig, width="stretch", config={"responsive": True})
     else:
         st.warning("No politician data available")
 
@@ -447,7 +472,7 @@ def show_disclosures():
             ]
 
         # Display data
-        st.dataframe(filtered, use_container_width=True)
+        st.dataframe(filtered, width="stretch")
 
         # Analysis
         if not filtered.empty:
@@ -463,7 +488,7 @@ def show_disclosures():
                         y=daily_volume.values,
                         title="Trading Volume Over Time",
                     )
-                    st.plotly_chart(fig, use_container_width=True)
+                    st.plotly_chart(fig, width="stretch", config={"responsive": True})
 
             with col2:
                 # Top politicians by trading
@@ -475,7 +500,7 @@ def show_disclosures():
                         orientation="h",
                         title="Most Active Traders",
                     )
-                    st.plotly_chart(fig, use_container_width=True)
+                    st.plotly_chart(fig, width="stretch", config={"responsive": True})
     else:
         st.warning("No disclosure data available")
 
@@ -487,14 +512,14 @@ def show_predictions():
     predictions = get_predictions_data()
 
     if not predictions.empty:
-        st.dataframe(predictions, use_container_width=True)
+        st.dataframe(predictions, width="stretch")
 
         # Add prediction analysis charts if we have data
         if "confidence" in predictions:
             fig = px.histogram(
                 predictions, x="confidence", title="Prediction Confidence Distribution"
             )
-            st.plotly_chart(fig, use_container_width=True)
+            st.plotly_chart(fig, width="stretch", config={"responsive": True})
     else:
         st.info(
             "No ML predictions available yet. The ML pipeline will generate predictions once sufficient data is collected."
@@ -521,7 +546,7 @@ def show_jobs():
             st.metric("Failed", status_counts.get("failed", 0))
 
         # Jobs table
-        st.dataframe(jobs, use_container_width=True)
+        st.dataframe(jobs, width="stretch")
 
         # Success rate over time
         if "created_at" in jobs:
@@ -543,7 +568,7 @@ def show_jobs():
                 )
 
             fig.update_layout(title="Job Status Over Time", xaxis_title="Date", yaxis_title="Count")
-            st.plotly_chart(fig, use_container_width=True)
+            st.plotly_chart(fig, width="stretch", config={"responsive": True})
     else:
         st.warning("No job data available")
 
@@ -617,11 +642,11 @@ def show_system_health():
 
     col1, col2 = st.columns(2)
     with col1:
-        st.dataframe(stats_df, use_container_width=True)
+        st.dataframe(stats_df, width="stretch")
 
     with col2:
         fig = px.bar(stats_df, x="Entity", y="Count", title="Database Records")
-        st.plotly_chart(fig, use_container_width=True)
+        st.plotly_chart(fig, width="stretch", config={"responsive": True})
 
 
 if __name__ == "__main__":

mcli/ml/dashboard/app_training.py

@@ -203,7 +203,7 @@ def show_model_comparison():
         sorted_df.style.highlight_max(
             subset=["test_accuracy", "r2"], color="lightgreen"
         ).highlight_min(subset=["test_loss", "rmse", "mae"], color="lightgreen"),
-        use_container_width=True,
+        width="stretch",
     )
 
     # Visualization section
@@ -222,7 +222,7 @@ def show_model_comparison():
             labels={"value": "Accuracy", "variable": "Split"},
         )
         fig.update_layout(xaxis_tickangle=-45)
-        st.plotly_chart(fig, use_container_width=True)
+        st.plotly_chart(fig, width="stretch", config={"responsive": True})
 
     with col2:
         # Loss comparison
@@ -235,7 +235,7 @@ def show_model_comparison():
             labels={"value": "Loss", "variable": "Split"},
         )
         fig.update_layout(xaxis_tickangle=-45)
-        st.plotly_chart(fig, use_container_width=True)
+        st.plotly_chart(fig, width="stretch", config={"responsive": True})
 
     # Additional metrics if available
     if models_df["rmse"].max() > 0:
@@ -253,7 +253,7 @@ def show_model_comparison():
                 hover_data=["name"],
                 title="RMSE vs MAE (sized by R²)",
             )
-            st.plotly_chart(fig, use_container_width=True)
+            st.plotly_chart(fig, width="stretch", config={"responsive": True})
 
         with col2:
             # R² score comparison
@@ -267,7 +267,7 @@ def show_model_comparison():
                 color_continuous_scale="Greens",
             )
             fig.update_layout(xaxis_tickangle=-45)
-            st.plotly_chart(fig, use_container_width=True)
+            st.plotly_chart(fig, width="stretch", config={"responsive": True})
 
 
 def show_residual_analysis():
@@ -313,7 +313,7 @@ def show_residual_analysis():
         fig.update_layout(
             xaxis_title="Prediction Index", yaxis_title="Residuals", hovermode="x unified"
         )
-        st.plotly_chart(fig, use_container_width=True)
+        st.plotly_chart(fig, width="stretch", config={"responsive": True})
 
         # Statistics
         col1, col2, col3 = st.columns(3)
@@ -347,7 +347,7 @@ def show_residual_analysis():
         )
 
         fig.update_layout(xaxis_title="Residuals", yaxis_title="Frequency", showlegend=True)
-        st.plotly_chart(fig, use_container_width=True)
+        st.plotly_chart(fig, width="stretch", config={"responsive": True})
 
         # Normality tests
         _, p_value = stats.normaltest(residuals)
@@ -389,7 +389,7 @@ def show_residual_analysis():
             yaxis_title="Sample Quantiles",
             title="Q-Q Plot (Normal Distribution)",
         )
-        st.plotly_chart(fig, use_container_width=True)
+        st.plotly_chart(fig, width="stretch", config={"responsive": True})
 
         st.info(f"Correlation with normal distribution: {r:.4f}")
 
@@ -415,7 +415,7 @@ def show_residual_analysis():
             yaxis_title="Residuals",
             title="Residuals vs Predicted (looking for patterns)",
         )
-        st.plotly_chart(fig, use_container_width=True)
+        st.plotly_chart(fig, width="stretch", config={"responsive": True})
 
         st.info(
             "💡 Ideally, residuals should be randomly scattered around zero with no clear patterns."
@@ -463,11 +463,11 @@ def show_feature_importance():
                 color_continuous_scale="Viridis",
             )
             fig.update_layout(height=600, yaxis={"categoryorder": "total ascending"})
-            st.plotly_chart(fig, use_container_width=True)
+            st.plotly_chart(fig, width="stretch", config={"responsive": True})
 
             # Feature importance table
             st.subheader("Feature Importance Table")
-            st.dataframe(feature_df.head(top_n), use_container_width=True)
+            st.dataframe(feature_df.head(top_n), width="stretch")
 
             # Feature categories (similar to bitcoin project)
             st.subheader("Feature Categories")
@@ -524,7 +524,7 @@ def show_feature_importance():
                     names="Category",
                     title="Feature Importance by Category",
                 )
-                st.plotly_chart(fig, use_container_width=True)
+                st.plotly_chart(fig, width="stretch", config={"responsive": True})
         else:
             st.warning("No feature information available for this model")
     finally:
@@ -565,7 +565,7 @@ def show_training_history():
     display_df = jobs_df[["name", "status", "started_at", "duration_seconds"]].copy()
     display_df["duration_minutes"] = display_df["duration_seconds"] / 60
 
-    st.dataframe(display_df, use_container_width=True)
+    st.dataframe(display_df, width="stretch")
 
     # Training duration distribution
     if not jobs_df["duration_seconds"].isna().all():
@@ -578,7 +578,7 @@ def show_training_history():
             title="Training Duration Distribution",
             labels={"duration_seconds": "Duration (seconds)"},
         )
-        st.plotly_chart(fig, use_container_width=True)
+        st.plotly_chart(fig, width="stretch", config={"responsive": True})
 
 
 def main():

mcli/ml/dashboard/components/charts.py

@@ -0,0 +1,258 @@
+"""Reusable chart components for Streamlit dashboards"""
+
+import plotly.graph_objects as go
+import plotly.express as px
+import pandas as pd
+import streamlit as st
+from typing import Optional, Dict, List, Any
+
+
+def create_timeline_chart(
+    data: pd.DataFrame,
+    x_col: str,
+    y_col: str,
+    title: str = "Timeline",
+    color_col: Optional[str] = None,
+    height: int = 400
+) -> go.Figure:
+    """Create a timeline chart with Plotly"""
+
+    fig = px.line(
+        data,
+        x=x_col,
+        y=y_col,
+        color=color_col,
+        title=title,
+        markers=True
+    )
+
+    fig.update_layout(
+        height=height,
+        hovermode='x unified',
+        showlegend=True if color_col else False
+    )
+
+    return fig
+
+
+def create_status_pie_chart(
+    data: pd.DataFrame,
+    status_col: str,
+    title: str = "Status Distribution",
+    color_map: Optional[Dict[str, str]] = None
+) -> go.Figure:
+    """Create a pie chart for status distribution"""
+
+    status_counts = data[status_col].value_counts()
+
+    if color_map is None:
+        color_map = {
+            'completed': '#10b981',
+            'running': '#3b82f6',
+            'pending': '#f59e0b',
+            'failed': '#ef4444',
+            'cancelled': '#6b7280'
+        }
+
+    colors = [color_map.get(status.lower(), '#6b7280') for status in status_counts.index]
+
+    fig = go.Figure(data=[go.Pie(
+        labels=status_counts.index,
+        values=status_counts.values,
+        marker=dict(colors=colors),
+        hole=0.4
+    )])
+
+    fig.update_layout(
+        title=title,
+        height=350,
+        showlegend=True
+    )
+
+    return fig
+
+
+def create_metric_trend_chart(
+    data: pd.DataFrame,
+    time_col: str,
+    metric_col: str,
+    title: str,
+    target_value: Optional[float] = None
+) -> go.Figure:
+    """Create a metric trend chart with optional target line"""
+
+    fig = go.Figure()
+
+    # Add metric line
+    fig.add_trace(go.Scatter(
+        x=data[time_col],
+        y=data[metric_col],
+        mode='lines+markers',
+        name=metric_col,
+        line=dict(width=3),
+        marker=dict(size=8)
+    ))
+
+    # Add target line if specified
+    if target_value is not None:
+        fig.add_hline(
+            y=target_value,
+            line_dash="dash",
+            line_color="red",
+            annotation_text=f"Target: {target_value}"
+        )
+
+    fig.update_layout(
+        title=title,
+        xaxis_title=time_col,
+        yaxis_title=metric_col,
+        height=400,
+        hovermode='x unified'
+    )
+
+    return fig
+
+
+def create_heatmap(
+    data: pd.DataFrame,
+    x_col: str,
+    y_col: str,
+    value_col: str,
+    title: str = "Heatmap",
+    color_scale: str = "Blues"
+) -> go.Figure:
+    """Create a heatmap visualization"""
+
+    pivot_data = data.pivot_table(
+        index=y_col,
+        columns=x_col,
+        values=value_col,
+        aggfunc='mean'
+    )
+
+    fig = px.imshow(
+        pivot_data,
+        color_continuous_scale=color_scale,
+        title=title,
+        aspect="auto"
+    )
+
+    fig.update_layout(height=400)
+
+    return fig
+
+
+def create_gantt_chart(
+    data: pd.DataFrame,
+    task_col: str,
+    start_col: str,
+    end_col: str,
+    status_col: Optional[str] = None,
+    title: str = "Timeline"
+) -> go.Figure:
+    """Create a Gantt chart for job/task scheduling"""
+
+    fig = px.timeline(
+        data,
+        x_start=start_col,
+        x_end=end_col,
+        y=task_col,
+        color=status_col,
+        title=title
+    )
+
+    fig.update_yaxes(categoryorder="total ascending")
+    fig.update_layout(height=max(400, len(data) * 30))
+
+    return fig
+
+
+def create_multi_metric_gauge(
+    values: Dict[str, float],
+    max_values: Dict[str, float],
+    title: str = "Metrics"
+) -> go.Figure:
+    """Create multiple gauge charts in a grid"""
+
+    from plotly.subplots import make_subplots
+
+    n_metrics = len(values)
+    cols = min(3, n_metrics)
+    rows = (n_metrics + cols - 1) // cols
+
+    fig = make_subplots(
+        rows=rows,
+        cols=cols,
+        specs=[[{'type': 'indicator'}] * cols] * rows,
+        subplot_titles=list(values.keys())
+    )
+
+    for idx, (metric, value) in enumerate(values.items()):
+        row = idx // cols + 1
+        col = idx % cols + 1
+        max_val = max_values.get(metric, 100)
+
+        fig.add_trace(
+            go.Indicator(
+                mode="gauge+number+delta",
+                value=value,
+                title={'text': metric},
+                gauge={
+                    'axis': {'range': [None, max_val]},
+                    'bar': {'color': "darkblue"},
+                    'steps': [
+                        {'range': [0, max_val * 0.5], 'color': "lightgray"},
+                        {'range': [max_val * 0.5, max_val * 0.8], 'color': "gray"}
+                    ],
+                    'threshold': {
+                        'line': {'color': "red", 'width': 4},
+                        'thickness': 0.75,
+                        'value': max_val * 0.9
+                    }
+                }
+            ),
+            row=row,
+            col=col
+        )
+
+    fig.update_layout(
+        title=title,
+        height=300 * rows
+    )
+
+    return fig
+
+
+def create_waterfall_chart(
+    categories: List[str],
+    values: List[float],
+    title: str = "Waterfall Chart"
+) -> go.Figure:
+    """Create a waterfall chart for step-by-step changes"""
+
+    fig = go.Figure(go.Waterfall(
+        name="",
+        orientation="v",
+        measure=["relative"] * (len(values) - 1) + ["total"],
+        x=categories,
+        y=values,
+        connector={"line": {"color": "rgb(63, 63, 63)"}},
+    ))
+
+    fig.update_layout(
+        title=title,
+        showlegend=False,
+        height=400
+    )
+
+    return fig
+
+
+def render_chart(fig: go.Figure, key: Optional[str] = None):
+    """Helper to render Plotly chart with consistent configuration"""
+    st.plotly_chart(
+        fig,
+        width="stretch",
+        config={"responsive": True},
+        key=key
+    )

mcli/ml/dashboard/components/metrics.py

@@ -0,0 +1,125 @@
+"""Reusable metric display components"""
+
+import streamlit as st
+from typing import Optional, Union
+
+
+def display_metric_card(
+    label: str,
+    value: Union[int, float, str],
+    delta: Optional[Union[int, float, str]] = None,
+    delta_color: str = "normal",
+    help_text: Optional[str] = None,
+    icon: Optional[str] = None
+):
+    """Display a metric card with optional delta and icon"""
+
+    if icon:
+        label = f"{icon} {label}"
+
+    st.metric(
+        label=label,
+        value=value,
+        delta=delta,
+        delta_color=delta_color,
+        help=help_text
+    )
+
+
+def display_status_badge(
+    status: str,
+    size: str = "medium"
+) -> str:
+    """Return a colored status badge"""
+
+    status_colors = {
+        'completed': '🟢',
+        'success': '🟢',
+        'running': '🔵',
+        'in_progress': '🔵',
+        'pending': '🟡',
+        'waiting': '🟡',
+        'failed': '🔴',
+        'error': '🔴',
+        'cancelled': '⚪',
+        'unknown': '⚫'
+    }
+
+    icon = status_colors.get(status.lower(), '⚫')
+
+    if size == "small":
+        return f"{icon} {status}"
+    elif size == "large":
+        return f"## {icon} {status}"
+    else:  # medium
+        return f"### {icon} {status}"
+
+
+def display_kpi_row(metrics: dict, columns: Optional[int] = None):
+    """Display a row of KPIs in columns"""
+
+    if columns is None:
+        columns = len(metrics)
+
+    cols = st.columns(columns)
+
+    for idx, (label, value) in enumerate(metrics.items()):
+        with cols[idx % columns]:
+            if isinstance(value, dict):
+                display_metric_card(
+                    label=label,
+                    value=value.get('value', '-'),
+                    delta=value.get('delta'),
+                    delta_color=value.get('delta_color', 'normal'),
+                    help_text=value.get('help'),
+                    icon=value.get('icon')
+                )
+            else:
+                st.metric(label=label, value=value)
+
+
+def display_progress_bar(
+    label: str,
+    progress: float,
+    show_percentage: bool = True
+):
+    """Display a progress bar with label"""
+
+    st.text(label)
+    st.progress(min(1.0, max(0.0, progress)))
+
+    if show_percentage:
+        st.caption(f"{progress * 100:.1f}%")
+
+
+def display_health_indicator(
+    component: str,
+    is_healthy: bool,
+    details: Optional[str] = None
+):
+    """Display a health status indicator"""
+
+    if is_healthy:
+        st.success(f"✅ {component}: Healthy" + (f" ({details})" if details else ""))
+    else:
+        st.error(f"❌ {component}: Unhealthy" + (f" ({details})" if details else ""))
+
+
+def display_alert(
+    message: str,
+    alert_type: str = "info",
+    icon: Optional[str] = None
+):
+    """Display an alert message"""
+
+    if icon:
+        message = f"{icon} {message}"
+
+    if alert_type == "success":
+        st.success(message)
+    elif alert_type == "warning":
+        st.warning(message)
+    elif alert_type == "error":
+        st.error(message)
+    else:  # info
+        st.info(message)