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

mcli/ml/dashboard/pages/gravity_viz.py

@@ -10,6 +10,8 @@ import plotly.express as px
 from datetime import datetime, timedelta
 from typing import List, Dict, Optional, Tuple
 import numpy as np
+import os
+from supabase import Client, create_client
 
 # Configure page
 st.set_page_config(
@@ -50,6 +52,25 @@ st.markdown("""
 """, unsafe_allow_html=True)
 
 
+@st.cache_resource
+def get_supabase_client() -> Optional[Client]:
+    """Get Supabase client with Streamlit Cloud secrets support"""
+    try:
+        url = st.secrets.get("SUPABASE_URL", "")
+        key = st.secrets.get("SUPABASE_KEY", "") or st.secrets.get("SUPABASE_SERVICE_ROLE_KEY", "")
+    except (AttributeError, FileNotFoundError):
+        url = os.getenv("SUPABASE_URL", "")
+        key = os.getenv("SUPABASE_KEY", "") or os.getenv("SUPABASE_SERVICE_ROLE_KEY", "")
+
+    if not url or not key:
+        return None
+
+    try:
+        return create_client(url, key)
+    except Exception:
+        return None
+
+
 class GravityData:
     """Simulates gravity measurement data (in production, would fetch from real sensors/APIs)"""
 
@@ -98,12 +119,236 @@ class GravityData:
 class PoliticianLocations:
     """Manages politician location and trading data"""
 
+    # Approximate coordinates for major cities (used as fallback)
+    STATE_CAPITALS = {
+        # US States (capital cities)
+        'Alabama': (32.3668, -86.3000),
+        'California': (38.5816, -121.4944),
+        'Texas': (30.2672, -97.7431),
+        'New Jersey': (40.2206, -74.7597),
+        'Florida': (30.4383, -84.2807),
+        'New York': (42.6526, -73.7562),
+        'Pennsylvania': (40.2732, -76.8867),
+        'Illinois': (39.7817, -89.6501),
+        'Ohio': (39.9612, -82.9988),
+        'Georgia': (33.7490, -84.3880),
+        'Michigan': (42.7325, -84.5555),
+        'North Carolina': (35.7796, -78.6382),
+        'Virginia': (37.5407, -77.4360),
+        'Washington': (47.0379, -122.9007),
+        'Massachusetts': (42.3601, -71.0589),
+        # UK
+        'United Kingdom': (51.5074, -0.1278),  # London
+        'UK': (51.5074, -0.1278),
+        # EU Countries (capitals)
+        'France': (48.8566, 2.3522),  # Paris
+        'Germany': (52.5200, 13.4050),  # Berlin
+        'Italy': (41.9028, 12.4964),  # Rome
+        'Spain': (40.4168, -3.7038),  # Madrid
+        'Poland': (52.2297, 21.0122),  # Warsaw
+        'Netherlands': (52.3676, 4.9041),  # Amsterdam
+        'Belgium': (50.8503, 4.3517),  # Brussels
+        'Sweden': (59.3293, 18.0686),  # Stockholm
+        'Austria': (48.2082, 16.3738),  # Vienna
+        'Denmark': (55.6761, 12.5683),  # Copenhagen
+        'Finland': (60.1699, 24.9384),  # Helsinki
+    }
+
+    # Major city coordinates for district approximations
+    MAJOR_CITIES = {
+        # California
+        'San Francisco': (37.7749, -122.4194),
+        'Los Angeles': (34.0522, -118.2437),
+        'San Diego': (32.7157, -117.1611),
+        'Sacramento': (38.5816, -121.4944),
+        'San Jose': (37.3382, -121.8863),
+        # Texas
+        'Houston': (29.7604, -97.7431),
+        'Dallas': (32.7767, -96.7970),
+        'Austin': (30.2672, -97.7431),
+        'San Antonio': (29.4241, -98.4936),
+        # New York
+        'New York City': (40.7128, -74.0060),
+        'Buffalo': (42.8864, -78.8784),
+        'Rochester': (43.1566, -77.6088),
+        'Albany': (42.6526, -73.7562),
+        # Florida
+        'Miami': (25.7617, -80.1918),
+        'Tampa': (27.9506, -82.4572),
+        'Orlando': (28.5383, -81.3792),
+        'Jacksonville': (30.3322, -81.6557),
+        'Tallahassee': (30.4383, -84.2807),
+        # Pennsylvania
+        'Philadelphia': (39.9526, -75.1652),
+        'Pittsburgh': (40.4406, -79.9959),
+        'Harrisburg': (40.2732, -76.8867),
+        # Illinois
+        'Chicago': (41.8781, -87.6298),
+        'Springfield': (39.7817, -89.6501),
+        # New Jersey
+        'Newark': (40.7357, -74.1724),
+        'Jersey City': (40.7178, -74.0431),
+        'Trenton': (40.2206, -74.7597),
+        # And more major cities as needed...
+    }
+
     @staticmethod
-    def get_sample_politicians() -> pd.DataFrame:
+    def get_location_for_politician(state_or_country: str, district: str, role: str) -> Tuple[float, float]:
         """
-        Sample politician data with locations
-        In production: integrate with mcli's politician_trading database
+        Get lat/lon for a politician based on their state/district/role
+        Returns: (latitude, longitude)
         """
+        # For US Congress members with districts, try to use district-specific locations
+        if district and state_or_country in ['California', 'Texas', 'New York', 'Florida', 'Pennsylvania', 'Illinois', 'New Jersey']:
+            # Parse district like "CA-11" or "TX-02"
+            if '-' in str(district):
+                district_num = district.split('-')[-1]
+
+                # District-specific mapping (approximate major city in district)
+                # This is a simplified approach - in production, use actual district boundaries
+                district_locations = {
+                    # California districts (examples)
+                    'California': {
+                        '11': (37.7749, -122.4194),  # SF Bay Area
+                        '12': (37.7749, -122.4194),  # SF
+                        '13': (37.3382, -121.8863),  # Oakland/East Bay
+                        '17': (37.3382, -121.8863),  # San Jose area
+                        '28': (34.0522, -118.2437),  # LA
+                        '43': (33.7701, -118.1937),  # Long Beach
+                    },
+                    # Texas districts
+                    'Texas': {
+                        '02': (29.7604, -97.7431),  # Houston
+                        '07': (29.7604, -97.7431),  # Houston
+                        '24': (32.7767, -96.7970),  # Dallas
+                        '21': (29.4241, -98.4936),  # San Antonio
+                    },
+                    # New York districts
+                    'New York': {
+                        '12': (40.7128, -74.0060),  # NYC Manhattan
+                        '14': (40.7128, -74.0060),  # NYC Bronx/Queens
+                        '26': (42.8864, -78.8784),  # Buffalo
+                    },
+                    # Add more as needed
+                }
+
+                if state_or_country in district_locations and district_num in district_locations[state_or_country]:
+                    # Add small random offset to prevent exact overlap
+                    base_lat, base_lon = district_locations[state_or_country][district_num]
+                    import random
+                    offset_lat = random.uniform(-0.1, 0.1)
+                    offset_lon = random.uniform(-0.1, 0.1)
+                    return (base_lat + offset_lat, base_lon + offset_lon)
+
+        # For senators or politicians without district mapping, use state capital with small offset
+        base_coords = PoliticianLocations.STATE_CAPITALS.get(state_or_country, (38.9072, -77.0369))
+
+        # Add small random offset to prevent exact overlap for multiple politicians from same location
+        import random
+        offset_lat = random.uniform(-0.2, 0.2)
+        offset_lon = random.uniform(-0.2, 0.2)
+
+        return (base_coords[0] + offset_lat, base_coords[1] + offset_lon)
+
+    @staticmethod
+    @st.cache_data(ttl=60)
+    def get_politicians_from_db() -> pd.DataFrame:
+        """Fetch politicians with trading data from database"""
+        client = get_supabase_client()
+        if not client:
+            return PoliticianLocations.get_fallback_politicians()
+
+        try:
+            # Fetch politicians
+            politicians_response = client.table("politicians").select("*").execute()
+            if not politicians_response.data:
+                return PoliticianLocations.get_fallback_politicians()
+
+            politicians_df = pd.DataFrame(politicians_response.data)
+
+            # Fetch trading disclosures to calculate volumes
+            disclosures_response = client.table("trading_disclosures").select("*").execute()
+            disclosures_df = pd.DataFrame(disclosures_response.data) if disclosures_response.data else pd.DataFrame()
+
+            # Calculate trading metrics per politician
+            result_data = []
+            for _, pol in politicians_df.iterrows():
+                pol_id = pol.get('id')
+                pol_disclosures = disclosures_df[disclosures_df['politician_id'] == pol_id] if not disclosures_df.empty else pd.DataFrame()
+
+                # Calculate metrics
+                recent_trades = len(pol_disclosures)
+                total_volume = 0
+                last_trade_date = None
+
+                if not pol_disclosures.empty:
+                    # Estimate volume from range midpoints
+                    for _, d in pol_disclosures.iterrows():
+                        min_amt = d.get('amount_range_min', 0) or 0
+                        max_amt = d.get('amount_range_max', 0) or 0
+                        if min_amt and max_amt:
+                            total_volume += (min_amt + max_amt) / 2
+                        elif d.get('amount_exact'):
+                            total_volume += d['amount_exact']
+
+                    # Get last trade date
+                    transaction_dates = pd.to_datetime(pol_disclosures['transaction_date'], errors='coerce')
+                    last_trade_date = transaction_dates.max()
+
+                # Get location based on state/district/role
+                state_or_country = pol.get('state_or_country', '')
+                district = pol.get('district', '')
+                role = pol.get('role', '')
+                lat, lon = PoliticianLocations.get_location_for_politician(
+                    state_or_country, district, role
+                )
+
+                # Build politician record - prefer first+last name over full_name if available
+                first_name = pol.get('first_name', '').strip()
+                last_name = pol.get('last_name', '').strip()
+                full_name = pol.get('full_name', '').strip()
+
+                # Use first_name + last_name if both available, otherwise use full_name
+                if first_name and last_name:
+                    display_name = f"{first_name} {last_name}"
+                elif full_name:
+                    display_name = full_name
+                elif first_name:
+                    display_name = first_name
+                elif last_name:
+                    display_name = last_name
+                else:
+                    display_name = f"Politician {pol_id[:8]}"  # Fallback to ID
+
+                result_data.append({
+                    'name': display_name,
+                    'role': pol.get('role', 'Unknown'),
+                    'state': state_or_country,
+                    'district': pol.get('district'),
+                    'party': pol.get('party', 'Unknown'),
+                    'lat': lat,
+                    'lon': lon,
+                    'recent_trades': recent_trades,
+                    'total_trade_volume': total_volume,
+                    'last_trade_date': last_trade_date if pd.notna(last_trade_date) else datetime(2025, 1, 1),
+                })
+
+            result_df = pd.DataFrame(result_data)
+            # Filter out politicians with no trading data
+            result_df = result_df[result_df['recent_trades'] > 0]
+
+            if result_df.empty:
+                return PoliticianLocations.get_fallback_politicians()
+
+            return result_df
+
+        except Exception as e:
+            st.warning(f"Could not fetch politicians from database: {e}")
+            return PoliticianLocations.get_fallback_politicians()
+
+    @staticmethod
+    def get_fallback_politicians() -> pd.DataFrame:
+        """Fallback sample data if database is unavailable"""
         politicians = [
             {
                 'name': 'Nancy Pelosi',
@@ -111,7 +356,7 @@ class PoliticianLocations:
                 'state': 'California',
                 'district': 'CA-11',
                 'party': 'Democrat',
-                'lat': 37.7749,  # San Francisco
+                'lat': 37.7749,
                 'lon': -122.4194,
                 'recent_trades': 15,
                 'total_trade_volume': 5_000_000,
@@ -123,50 +368,13 @@ class PoliticianLocations:
                 'state': 'Alabama',
                 'district': None,
                 'party': 'Republican',
-                'lat': 32.3668,  # Montgomery
+                'lat': 32.3668,
                 'lon': -86.3000,
                 'recent_trades': 23,
                 'total_trade_volume': 3_200_000,
                 'last_trade_date': datetime(2025, 10, 3),
             },
-            {
-                'name': 'Josh Gottheimer',
-                'role': 'US House Representative',
-                'state': 'New Jersey',
-                'district': 'NJ-05',
-                'party': 'Democrat',
-                'lat': 40.9168,  # Ridgewood
-                'lon': -74.1168,
-                'recent_trades': 12,
-                'total_trade_volume': 2_800_000,
-                'last_trade_date': datetime(2025, 10, 7),
-            },
-            {
-                'name': 'Dan Crenshaw',
-                'role': 'US House Representative',
-                'state': 'Texas',
-                'district': 'TX-02',
-                'party': 'Republican',
-                'lat': 29.7604,  # Houston
-                'lon': -95.3698,
-                'recent_trades': 18,
-                'total_trade_volume': 4_100_000,
-                'last_trade_date': datetime(2025, 10, 6),
-            },
-            {
-                'name': 'Ro Khanna',
-                'role': 'US House Representative',
-                'state': 'California',
-                'district': 'CA-17',
-                'party': 'Democrat',
-                'lat': 37.3861,  # San Jose
-                'lon': -121.8947,
-                'recent_trades': 8,
-                'total_trade_volume': 1_500_000,
-                'last_trade_date': datetime(2025, 10, 4),
-            },
         ]
-
         return pd.DataFrame(politicians)
 
 
@@ -386,8 +594,11 @@ def main():
     # Sidebar
     st.sidebar.header("⚙️ Configuration")
 
-    # Load politician data
-    politicians_df = PoliticianLocations.get_sample_politicians()
+    # Load politician data from database
+    politicians_df = PoliticianLocations.get_politicians_from_db()
+
+    # Show data info
+    st.sidebar.info(f"📊 Loaded {len(politicians_df)} politicians with trading data")
 
     # Politician selection
     selected_politician = st.sidebar.selectbox(
@@ -411,9 +622,10 @@ def main():
         "Minimum Trade Volume ($)",
         min_value=0,
         max_value=10_000_000,
-        value=1_000_000,
-        step=500_000,
-        format="%d"
+        value=0,  # Changed from 1,000,000 to 0 to show all politicians by default
+        step=100_000,
+        format="%d",
+        help="Filter politicians by minimum trade volume. Set to 0 to see all."
     )
 
     # Filter politicians by trade volume
@@ -421,6 +633,12 @@ def main():
         politicians_df['total_trade_volume'] >= min_trade_volume
     ]
 
+    # Show filter results
+    if len(filtered_politicians) < len(politicians_df):
+        st.sidebar.warning(f"⚠️ Filter reduced to {len(filtered_politicians)} politicians (from {len(politicians_df)})")
+    else:
+        st.sidebar.success(f"✅ Showing all {len(filtered_politicians)} politicians")
+
     # Main content
     if selected_politician != 'All':
         # Single politician view

mcli/ml/dashboard/pages/predictions_enhanced.py

@@ -310,7 +310,8 @@ def show_active_predictions(predictions_df: pd.DataFrame):
             with st.container():
                 cols = st.columns([2, 1, 1, 1])
                 with cols[0]:
-                    st.markdown(f"**{row['ticker']}** - {row['sector']}")
+                    st.markdown(f"### 📈 {row['ticker']}")
+                    st.caption(f"{row['sector']}")
                 with cols[1]:
                     st.metric("Return", f"{row['predicted_return']*100:+.1f}%")
                 with cols[2]:
@@ -327,7 +328,8 @@ def show_active_predictions(predictions_df: pd.DataFrame):
             with st.container():
                 cols = st.columns([2, 1, 1, 1])
                 with cols[0]:
-                    st.markdown(f"**{row['ticker']}** - {row['sector']}")
+                    st.markdown(f"### 📈 {row['ticker']}")
+                    st.caption(f"{row['sector']}")
                 with cols[1]:
                     st.metric("Return", f"{row['predicted_return']*100:+.1f}%")
                 with cols[2]:

mcli/ml/dashboard/pages/scrapers_and_logs.py

@@ -736,10 +736,10 @@ def run_senate_watcher_scraper(
                 st.markdown("#### Recent Trading Disclosures")
                 disc_df = pd.DataFrame([{
                     "Date": d.transaction_date.strftime("%Y-%m-%d") if hasattr(d.transaction_date, 'strftime') else str(d.transaction_date),
-                    "Politician": d.politician_bioguide_id,
-                    "Type": d.transaction_type,
+                    "Ticker": d.asset_ticker or "—",
                     "Asset": d.asset_name[:50],
-                    "Ticker": d.asset_ticker or "",
+                    "Type": d.transaction_type,
+                    "Politician": d.politician_bioguide_id,
                     "Min": f"${d.amount_range_min:,.0f}" if d.amount_range_min else "",
                     "Max": f"${d.amount_range_max:,.0f}" if d.amount_range_max else ""
                 } for d in disclosures[:100]])  # Limit to 100 for display

mcli/ml/dashboard/styles.py

@@ -0,0 +1,55 @@
+"""
+Shared CSS styles for MCLI ML Dashboards.
+
+This module centralizes all CSS styling to avoid duplication across dashboard files.
+"""
+
+# Standard dashboard CSS used across all dashboard variants
+DASHBOARD_CSS = """
+<style>
+    .metric-card {
+        background-color: #f0f2f6;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        border-left: 4px solid #1f77b4;
+    }
+    .alert-success {
+        background-color: #d4edda;
+        border: 1px solid #c3e6cb;
+        color: #155724;
+        padding: 0.75rem;
+        border-radius: 0.25rem;
+    }
+    .alert-warning {
+        background-color: #fff3cd;
+        border: 1px solid #ffeaa7;
+        color: #856404;
+        padding: 0.75rem;
+        border-radius: 0.25rem;
+    }
+    .alert-danger {
+        background-color: #f8d7da;
+        border: 1px solid #f5c6cb;
+        color: #721c24;
+        padding: 0.75rem;
+        border-radius: 0.25rem;
+    }
+</style>
+"""
+
+
+def apply_dashboard_styles():
+    """
+    Apply standard dashboard CSS styles.
+
+    Call this function once in your dashboard to apply the standard styling.
+
+    Example:
+        import streamlit as st
+        from mcli.ml.dashboard.styles import apply_dashboard_styles
+
+        apply_dashboard_styles()
+    """
+    import streamlit as st
+
+    st.markdown(DASHBOARD_CSS, unsafe_allow_html=True)