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

mcli/ml/dashboard/streamlit_extras_utils.py

@@ -0,0 +1,297 @@
+"""Utility functions using streamlit-extras for enhanced dashboard UI"""
+
+import streamlit as st
+
+# Try to import streamlit-extras components
+HAS_EXTRAS = True
+try:
+    from streamlit_extras.metric_cards import style_metric_cards
+    from streamlit_extras.badges import badge
+    from streamlit_extras.colored_header import colored_header
+    from streamlit_extras.card import card
+    from streamlit_extras.stoggle import stoggle
+    from streamlit_extras.grid import grid
+    from streamlit_extras.add_vertical_space import add_vertical_space
+    from streamlit_extras.stylable_container import stylable_container
+except ImportError:
+    HAS_EXTRAS = False
+    style_metric_cards = None
+    badge = None
+    colored_header = None
+    card = None
+    stoggle = None
+    grid = None
+    add_vertical_space = None
+    stylable_container = None
+
+
+def enhanced_metrics(metrics_data: list, use_container_width: bool = True):
+    """
+    Display enhanced metric cards with styling from streamlit-extras
+
+    Args:
+        metrics_data: List of dicts with keys: label, value, delta (optional)
+        use_container_width: Whether to use full container width
+
+    Example:
+        enhanced_metrics([
+            {"label": "Total Transactions", "value": "1,234", "delta": "+12%"},
+            {"label": "Portfolio Value", "value": "$50,000", "delta": "-2.3%"},
+        ])
+    """
+    if not HAS_EXTRAS:
+        # Fallback to standard metrics
+        cols = st.columns(len(metrics_data))
+        for i, metric in enumerate(metrics_data):
+            with cols[i]:
+                st.metric(
+                    label=metric["label"],
+                    value=metric["value"],
+                    delta=metric.get("delta")
+                )
+        return
+
+    # Use streamlit-extras styled metrics
+    cols = st.columns(len(metrics_data))
+    for i, metric in enumerate(metrics_data):
+        with cols[i]:
+            st.metric(
+                label=metric["label"],
+                value=metric["value"],
+                delta=metric.get("delta")
+            )
+    style_metric_cards()
+
+
+def status_badge(label: str, url: str = None):
+    """
+    Display a status badge
+
+    Args:
+        label: Badge text (e.g., "Live", "Production", "Beta")
+        url: Optional URL to link to
+    """
+    if not HAS_EXTRAS:
+        st.markdown(f"**{label}**")
+        return
+
+    badge(type="success", name=label, url=url)
+
+
+def section_header(label: str, description: str = None, divider: str = "rainbow"):
+    """
+    Display a colored section header with optional description
+
+    Args:
+        label: Header text
+        description: Optional description text
+        divider: Color of divider line
+    """
+    if not HAS_EXTRAS:
+        st.header(label)
+        if description:
+            st.markdown(description)
+        st.divider()
+        return
+
+    colored_header(
+        label=label,
+        description=description or "",
+        color_name=divider
+    )
+
+
+def info_card(title: str, text: str, image: str = None, url: str = None,
+              has_button: bool = False, button_text: str = "Learn More"):
+    """
+    Display an information card
+
+    Args:
+        title: Card title
+        text: Card content
+        image: Optional image URL
+        url: Optional URL to link to
+        has_button: Whether to show a button
+        button_text: Button text if has_button is True
+    """
+    if not HAS_EXTRAS:
+        with st.container():
+            st.subheader(title)
+            if image:
+                st.image(image)
+            st.markdown(text)
+            if url and has_button:
+                st.link_button(button_text, url)
+        return
+
+    kwargs = {
+        "title": title,
+        "text": text,
+    }
+    if image:
+        kwargs["image"] = image
+    if url:
+        kwargs["url"] = url
+
+    card(**kwargs)
+
+
+def collapsible_section(label: str, content_fn, default_open: bool = False):
+    """
+    Create a collapsible toggle section
+
+    Args:
+        label: Section label
+        content_fn: Function to call to render content
+        default_open: Whether section starts open
+    """
+    if not HAS_EXTRAS:
+        with st.expander(label, expanded=default_open):
+            content_fn()
+        return
+
+    stoggle(label, content_fn)
+
+
+def dashboard_grid(num_cols: int = 3, gap: str = "medium"):
+    """
+    Create a responsive grid layout
+
+    Args:
+        num_cols: Number of columns
+        gap: Gap size between columns
+
+    Returns:
+        Grid object for use in with statement
+    """
+    if not HAS_EXTRAS:
+        return st.columns(num_cols)
+
+    return grid(num_cols, gap=gap)
+
+
+def vertical_space(lines: int = 1):
+    """
+    Add vertical spacing
+
+    Args:
+        lines: Number of lines to add
+    """
+    if not HAS_EXTRAS:
+        for _ in range(lines):
+            st.write("")
+        return
+
+    add_vertical_space(lines)
+
+
+def styled_container(key: str, css_styles: str):
+    """
+    Create a container with custom CSS styling
+
+    Args:
+        key: Unique key for the container
+        css_styles: CSS styles to apply
+
+    Returns:
+        Context manager for styled container
+    """
+    if not HAS_EXTRAS:
+        return st.container()
+
+    return stylable_container(
+        key=key,
+        css_styles=css_styles
+    )
+
+
+def trading_status_card(status: str, portfolio_value: float, daily_pnl: float,
+                       positions: int, cash: float):
+    """
+    Display a trading status summary card
+
+    Args:
+        status: Trading status (e.g., "Active", "Paused")
+        portfolio_value: Current portfolio value
+        daily_pnl: Daily profit/loss
+        positions: Number of open positions
+        cash: Available cash
+    """
+    status_color = "🟢" if status == "Active" else "🔴"
+    pnl_emoji = "📈" if daily_pnl >= 0 else "📉"
+    pnl_sign = "+" if daily_pnl >= 0 else ""
+
+    section_header(
+        f"{status_color} Trading Status: {status}",
+        f"Real-time portfolio monitoring and execution",
+        divider="blue"
+    )
+
+    enhanced_metrics([
+        {
+            "label": "Portfolio Value",
+            "value": f"${portfolio_value:,.2f}",
+            "delta": f"{pnl_sign}${daily_pnl:,.2f}"
+        },
+        {
+            "label": "Open Positions",
+            "value": str(positions),
+        },
+        {
+            "label": "Available Cash",
+            "value": f"${cash:,.2f}",
+        },
+    ])
+
+
+def data_quality_indicators(total_records: int, clean_records: int,
+                            errors: int, last_update: str):
+    """
+    Display data quality indicators
+
+    Args:
+        total_records: Total number of records
+        clean_records: Number of clean records
+        errors: Number of errors
+        last_update: Last update timestamp
+    """
+    quality_pct = (clean_records / total_records * 100) if total_records > 0 else 0
+
+    section_header(
+        "📊 Data Quality Metrics",
+        f"Last updated: {last_update}",
+        divider="green"
+    )
+
+    enhanced_metrics([
+        {
+            "label": "Total Records",
+            "value": f"{total_records:,}",
+        },
+        {
+            "label": "Data Quality",
+            "value": f"{quality_pct:.1f}%",
+            "delta": f"{clean_records:,} clean"
+        },
+        {
+            "label": "Errors",
+            "value": str(errors),
+            "delta": f"{(errors/total_records*100):.2f}%" if total_records > 0 else "0%"
+        },
+    ])
+
+
+# Export available components
+__all__ = [
+    'HAS_EXTRAS',
+    'enhanced_metrics',
+    'status_badge',
+    'section_header',
+    'info_card',
+    'collapsible_section',
+    'dashboard_grid',
+    'vertical_space',
+    'styled_container',
+    'trading_status_card',
+    'data_quality_indicators',
+]

mcli/ml/dashboard/utils.py

@@ -0,0 +1,161 @@
+"""Shared utility functions for dashboard pages"""
+
+import os
+import logging
+import warnings
+from typing import List, Optional
+import pandas as pd
+import streamlit as st
+from supabase import Client, create_client
+
+# Suppress Streamlit warnings when used outside runtime context
+warnings.filterwarnings("ignore", message=".*missing ScriptRunContext.*")
+warnings.filterwarnings("ignore", message=".*No runtime found.*")
+warnings.filterwarnings("ignore", message=".*Session state does not function.*")
+warnings.filterwarnings("ignore", message=".*to view this Streamlit app.*")
+
+logger = logging.getLogger(__name__)
+
+
+def get_supabase_client() -> Optional[Client]:
+    """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:
+        logger.warning("Supabase credentials not found")
+        return None
+
+    try:
+        client = create_client(url, key)
+        # Test connection with a simple query
+        try:
+            test_result = client.table("politicians").select("id").limit(1).execute()
+            logger.info(f"✅ Supabase connection successful (URL: {url[:30]}...)")
+            return client
+        except Exception as conn_error:
+            st.error(f"❌ Supabase connection failed: {conn_error}")
+            return None
+    except Exception as e:
+        logger.error(f"Failed to create Supabase client: {e}")
+        return None
+
+
+def get_politician_names() -> List[str]:
+    """Get all politician names from database for searchable dropdown"""
+    try:
+        client = get_supabase_client()
+        if not client:
+            return ["Nancy Pelosi", "Paul Pelosi", "Dan Crenshaw", "Josh Gottheimer"]  # Fallback
+
+        result = client.table("politicians").select("first_name, last_name").execute()
+        names = [f"{row['first_name']} {row['last_name']}" for row in result.data]
+        return names if names else ["Nancy Pelosi", "Paul Pelosi", "Dan Crenshaw", "Josh Gottheimer"]
+    except Exception as e:
+        logger.error(f"Failed to get politician names: {e}")
+        return ["Nancy Pelosi", "Paul Pelosi", "Dan Crenshaw", "Josh Gottheimer"]
+
+
+def get_disclosures_data() -> pd.DataFrame:
+    """Get trading disclosures from Supabase with proper schema mapping"""
+    client = get_supabase_client()
+    if not client:
+        return _generate_demo_disclosures()
+
+    try:
+        # First, get total count
+        count_response = (
+            client.table("trading_disclosures")
+            .select("*", count="exact")
+            .execute()
+        )
+        total_count = count_response.count
+
+        if total_count == 0:
+            return _generate_demo_disclosures()
+
+        # Get the data
+        response = (
+            client.table("trading_disclosures")
+            .select("*")
+            .order("disclosure_date", desc=True)
+            .limit(1000)
+            .execute()
+        )
+
+        if not response.data:
+            return _generate_demo_disclosures()
+
+        df = pd.DataFrame(response.data)
+        return df
+
+    except Exception as e:
+        logger.error(f"Failed to fetch disclosures: {e}")
+        return _generate_demo_disclosures()
+
+
+def _generate_demo_disclosures() -> pd.DataFrame:
+    """Generate demo trading disclosure data for testing"""
+    st.info("🔵 Using demo trading data (Supabase unavailable)")
+    
+    import random
+    from datetime import datetime, timedelta
+    
+    politicians = ["Nancy Pelosi", "Paul Pelosi", "Dan Crenshaw", "Josh Gottheimer"]
+    tickers = ["AAPL", "MSFT", "GOOGL", "AMZN", "NVDA", "TSLA", "META", "AMD"]
+    transaction_types = ["Purchase", "Sale"]
+    
+    data = []
+    for _ in range(50):
+        data.append({
+            "politician_name": random.choice(politicians),
+            "ticker_symbol": random.choice(tickers),
+            "transaction_type": random.choice(transaction_types),
+            "amount_min": random.randint(1000, 100000),
+            "amount_max": random.randint(100000, 1000000),
+            "disclosure_date": (datetime.now() - timedelta(days=random.randint(1, 365))).strftime("%Y-%m-%d"),
+            "asset_description": f"{random.choice(tickers)} Stock",
+        })
+    
+    return pd.DataFrame(data)
+
+
+def get_politician_trading_history(politician_name: str) -> pd.DataFrame:
+    """Get trading history for a specific politician"""
+    try:
+        client = get_supabase_client()
+        if not client:
+            return pd.DataFrame()  # Return empty if no client
+
+        # Split name into first and last
+        name_parts = politician_name.split()
+        if len(name_parts) < 2:
+            return pd.DataFrame()
+
+        first_name = name_parts[0]
+        last_name = " ".join(name_parts[1:])
+
+        # Get trading disclosures for this politician
+        response = (
+            client.table("trading_disclosures")
+            .select("*")
+            .eq("politician_name", politician_name)
+            .order("disclosure_date", desc=True)
+            .limit(100)
+            .execute()
+        )
+
+        if response.data:
+            return pd.DataFrame(response.data)
+        else:
+            return pd.DataFrame()
+
+    except Exception as e:
+        logger.warning(f"Failed to fetch trading history for {politician_name}: {e}")
+        return pd.DataFrame()

mcli/ml/dashboard/warning_suppression.py

@@ -0,0 +1,34 @@
+"""Warning suppression utilities for Streamlit components used outside runtime context"""
+
+import warnings
+import logging
+from contextlib import contextmanager
+
+
+@contextmanager
+def suppress_streamlit_warnings():
+    """Context manager to suppress Streamlit warnings when used outside runtime context"""
+    # Suppress specific Streamlit warnings
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", message=".*missing ScriptRunContext.*")
+        warnings.filterwarnings("ignore", message=".*No runtime found.*")
+        warnings.filterwarnings("ignore", message=".*Session state does not function.*")
+        warnings.filterwarnings("ignore", message=".*to view this Streamlit app.*")
+        
+        # Also suppress logging warnings from Streamlit
+        streamlit_logger = logging.getLogger("streamlit")
+        original_level = streamlit_logger.level
+        streamlit_logger.setLevel(logging.ERROR)
+        
+        try:
+            yield
+        finally:
+            streamlit_logger.setLevel(original_level)
+
+
+def suppress_streamlit_warnings_decorator(func):
+    """Decorator to suppress Streamlit warnings for a function"""
+    def wrapper(*args, **kwargs):
+        with suppress_streamlit_warnings():
+            return func(*args, **kwargs)
+    return wrapper

mcli/ml/data_ingestion/__init__.py

@@ -0,0 +1,39 @@
+"""Real-time data ingestion pipeline"""
+
+from .api_connectors import (
+    AlphaVantageConnector,
+    CongressionalDataAPI,
+    PolygonIOConnector,
+    QuiverQuantConnector,
+    StockMarketAPI,
+    YahooFinanceConnector,
+)
+from .data_pipeline import (
+    DataLoader,
+    DataTransformer,
+    DataValidator,
+    IngestionPipeline,
+)
+from .stream_processor import (
+    DataStream,
+    KafkaConsumer,
+    StreamProcessor,
+    WebSocketConsumer,
+)
+
+__all__ = [
+    "StreamProcessor",
+    "DataStream",
+    "KafkaConsumer",
+    "WebSocketConsumer",
+    "CongressionalDataAPI",
+    "StockMarketAPI",
+    "AlphaVantageConnector",
+    "YahooFinanceConnector",
+    "PolygonIOConnector",
+    "QuiverQuantConnector",
+    "IngestionPipeline",
+    "DataValidator",
+    "DataTransformer",
+    "DataLoader",
+]

mcli/ml/database/__init__.py

@@ -0,0 +1,47 @@
+"""Database models and utilities"""
+
+from .models import (
+    Alert,
+    BacktestResult,
+    Base,
+    DataVersion,
+    Experiment,
+    FeatureSet,
+    Model,
+    Politician,
+    Portfolio,
+    Prediction,
+    StockData,
+    Trade,
+    User,
+)
+from .session import (
+    AsyncSessionLocal,
+    SessionLocal,
+    async_engine,
+    engine,
+    get_async_db,
+    get_db,
+)
+
+__all__ = [
+    "Base",
+    "User",
+    "Trade",
+    "Politician",
+    "StockData",
+    "Prediction",
+    "Portfolio",
+    "Alert",
+    "BacktestResult",
+    "Experiment",
+    "Model",
+    "FeatureSet",
+    "DataVersion",
+    "get_db",
+    "get_async_db",
+    "SessionLocal",
+    "AsyncSessionLocal",
+    "engine",
+    "async_engine",
+]