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

mcli/ml/dashboard/app_training.py

@@ -12,24 +12,22 @@ from scipy import stats
 
 from mcli.ml.database.models import Experiment, Model, ModelStatus
 from mcli.ml.database.session import SessionLocal
+from mcli.ml.dashboard.common import setup_page_config
+from mcli.ml.dashboard.styles import apply_dashboard_styles
 
-st.set_page_config(
+# Page config - must be first
+setup_page_config(
     page_title="MCLI Training Dashboard",
-    page_icon="🔬",
-    layout="wide",
-    initial_sidebar_state="expanded",
+    page_icon="🔬"
 )
 
-# Custom CSS
+# Apply standard dashboard styles (includes metric-card)
+apply_dashboard_styles()
+
+# Add training-specific CSS
 st.markdown(
     """
 <style>
-    .metric-card {
-        background-color: #f0f2f6;
-        padding: 1rem;
-        border-radius: 0.5rem;
-        border-left: 4px solid #1f77b4;
-    }
     .model-card {
         background-color: #ffffff;
         padding: 1.5rem;

mcli/ml/dashboard/common.py

@@ -0,0 +1,167 @@
+"""
+Common utilities for MCLI ML Dashboards.
+
+This module provides shared functionality across all dashboard variants to avoid code duplication.
+"""
+
+import os
+import warnings
+from pathlib import Path
+from typing import Optional
+
+import streamlit as st
+from dotenv import load_dotenv
+
+
+def suppress_streamlit_warnings():
+    """
+    Suppress common Streamlit, Plotly, and media file warnings.
+
+    Call this at the top of your dashboard file before importing other modules.
+    """
+    # 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.*")
+
+    # Suppress Plotly deprecation warnings
+    warnings.filterwarnings("ignore", message=".*keyword arguments have been deprecated.*")
+    warnings.filterwarnings("ignore", message=".*Use `config` instead.*")
+
+    # Suppress media file errors
+    warnings.filterwarnings("ignore", message=".*MediaFileHandler.*")
+    warnings.filterwarnings("ignore", message=".*Missing file.*")
+    warnings.filterwarnings("ignore", message=".*Bad filename.*")
+
+    # Suppress general warnings
+    warnings.filterwarnings("ignore", category=UserWarning)
+    warnings.filterwarnings("ignore", category=FutureWarning)
+
+    # Suppress specific Streamlit media file errors in logging
+    import logging
+
+    logging.getLogger("streamlit.runtime.media_file_storage").setLevel(logging.ERROR)
+    logging.getLogger("streamlit.web.server.media_file_handler").setLevel(logging.ERROR)
+
+
+def setup_page_config(
+    page_title: str = "MCLI ML Dashboard",
+    page_icon: str = "📊",
+    layout: str = "wide",
+    initial_sidebar_state: str = "expanded",
+):
+    """
+    Configure Streamlit page with standard settings.
+
+    IMPORTANT: This must be called before any other Streamlit commands.
+
+    Args:
+        page_title: Title shown in browser tab
+        page_icon: Emoji or image icon
+        layout: "wide" or "centered"
+        initial_sidebar_state: "expanded" or "collapsed"
+
+    Example:
+        from mcli.ml.dashboard.common import setup_page_config
+
+        setup_page_config(page_title="ML Training Dashboard")
+    """
+    st.set_page_config(
+        page_title=page_title,
+        page_icon=page_icon,
+        layout=layout,
+        initial_sidebar_state=initial_sidebar_state,
+    )
+
+
+@st.cache_resource
+def get_supabase_client():
+    """
+    Get cached Supabase client with automatic credential detection.
+
+    Tries multiple sources in order:
+    1. Streamlit Cloud secrets (for deployed apps)
+    2. Environment variables (for local development)
+    3. .env.local file in supabase directory
+
+    Returns:
+        Supabase Client instance or None if credentials not found
+
+    Example:
+        from mcli.ml.dashboard.common import get_supabase_client
+
+        client = get_supabase_client()
+        if client:
+            data = client.table('politicians').select('*').execute()
+    """
+    from supabase import Client, create_client
+
+    # Try Streamlit secrets first (for Streamlit Cloud)
+    url = ""
+    key = ""
+
+    try:
+        url = st.secrets.get("SUPABASE_URL", "")
+        key = st.secrets.get("SUPABASE_KEY", "") or st.secrets.get("SUPABASE_SERVICE_ROLE_KEY", "")
+    except (AttributeError, FileNotFoundError, KeyError):
+        pass
+
+    # Fall back to environment variables (for local dev)
+    if not url or not key:
+        url = os.getenv("SUPABASE_URL", "")
+        key = os.getenv("SUPABASE_KEY", "") or os.getenv("SUPABASE_SERVICE_ROLE_KEY", "")
+
+    # Try loading from .env.local in supabase directory
+    if not url or not key:
+        env_path = Path(__file__).parent.parent.parent.parent.parent / "supabase" / ".env.local"
+        if env_path.exists():
+            load_dotenv(env_path)
+            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. Configure SUPABASE_URL and SUPABASE_KEY "
+            "in Streamlit Cloud secrets or environment variables."
+        )
+        return None
+
+    try:
+        client = create_client(url, key)
+
+        # Test connection with a simple query
+        try:
+            # Try politicians table first (most common)
+            client.table("politicians").select("id").limit(1).execute()
+        except Exception:
+            # If politicians table doesn't exist, try another table
+            pass
+
+        return client
+    except Exception as e:
+        st.error(f"❌ Failed to create Supabase client: {e}")
+        return None
+
+
+def load_environment_variables():
+    """
+    Load environment variables from various sources.
+
+    Tries loading from:
+    1. Current directory .env file
+    2. Parent supabase/.env.local file
+
+    Example:
+        from mcli.ml.dashboard.common import load_environment_variables
+
+        load_environment_variables()
+        api_key = os.getenv("API_KEY")
+    """
+    # Try current directory
+    load_dotenv()
+
+    # Try supabase directory
+    env_path = Path(__file__).parent.parent.parent.parent.parent / "supabase" / ".env.local"
+    if env_path.exists():
+        load_dotenv(env_path)

mcli/ml/dashboard/pages/cicd.py

@@ -121,12 +121,12 @@ def show_cicd_dashboard():
         if st.button("🔄 Refresh"):
             st.rerun()
     with col2:
-        auto_refresh = st.checkbox("Auto-refresh", value=True)
+        auto_refresh = st.checkbox("Auto-refresh (30s)", value=False)
 
     if auto_refresh:
-        import time
-        time.sleep(5)
-        st.rerun()
+        from streamlit_autorefresh import st_autorefresh
+        # Auto-refresh every 30 seconds
+        st_autorefresh(interval=30000, key="cicd_refresh")
 
     st.divider()
 

mcli/ml/dashboard/pages/debug_dependencies.py

@@ -126,74 +126,116 @@ Platform: {sys.platform}
     # List installed packages
     st.header("📋 Installed Packages")
 
+    # Check if uv is being used
+    uv_available = False
     try:
-        result = subprocess.run(
-            ["pip", "list", "--format=columns"],
-            capture_output=True,
-            text=True,
-            timeout=10
-        )
-
-        if result.returncode == 0:
-            # Search for alpaca-related packages
-            alpaca_packages = [
-                line for line in result.stdout.split("\n")
-                if "alpaca" in line.lower()
-            ]
-
-            if alpaca_packages:
-                st.success("Found alpaca-related packages:")
-                for pkg in alpaca_packages:
-                    st.code(pkg)
-            else:
-                st.error("⚠️ No alpaca-related packages found in pip list!")
-
-            with st.expander("📦 All Installed Packages (click to expand)"):
-                st.code(result.stdout)
-        else:
-            st.error("Failed to run pip list")
-            st.code(result.stderr)
+        uv_check = subprocess.run(["uv", "--version"], capture_output=True, text=True, timeout=5)
+        uv_available = uv_check.returncode == 0
+        if uv_available:
+            st.info(f"🚀 Detected `uv` package manager: {uv_check.stdout.strip()}")
+    except:
+        pass
+
+    # Try uv pip list first (for Streamlit Cloud), fallback to pip
+    package_managers = []
+    if uv_available:
+        package_managers.append(("uv", ["uv", "pip", "list", "--format=columns"]))
+    package_managers.append(("pip", ["pip", "list", "--format=columns"]))
+
+    packages_found = False
+
+    for pm_name, pm_command in package_managers:
+        try:
+            result = subprocess.run(
+                pm_command,
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+
+            if result.returncode == 0:
+                packages_found = True
+
+                # Search for alpaca-related packages
+                alpaca_packages = [
+                    line for line in result.stdout.split("\n")
+                    if "alpaca" in line.lower()
+                ]
+
+                if alpaca_packages:
+                    st.success(f"✅ Found alpaca packages in `{pm_name}` list:")
+                    for pkg in alpaca_packages:
+                        st.code(pkg)
+
+                with st.expander(f"📦 All Installed Packages from `{pm_name}` (click to expand)"):
+                    st.code(result.stdout)
+
+                break  # Stop after first successful listing
+
+        except subprocess.TimeoutExpired:
+            st.warning(f"`{pm_name} list` command timed out")
+        except Exception as e:
+            st.warning(f"Could not run `{pm_name} list`: {str(e)}")
 
-    except subprocess.TimeoutExpired:
-        st.error("pip list command timed out")
-    except Exception as e:
-        st.error(f"Error running pip list: {str(e)}")
+    if not packages_found:
+        st.error("❌ Could not list packages from any package manager")
 
     # Check for specific alpaca-py installation
     st.header("🔎 Alpaca-py Installation Check")
 
-    try:
-        result = subprocess.run(
-            ["pip", "show", "alpaca-py"],
-            capture_output=True,
-            text=True,
-            timeout=10
-        )
-
-        if result.returncode == 0:
-            st.success("✅ alpaca-py package is installed!")
-            st.code(result.stdout)
-
-            # Try to get the version
-            try:
-                import alpaca
-                if hasattr(alpaca, "__version__"):
-                    st.info(f"Alpaca version from import: {alpaca.__version__}")
-            except:
-                pass
-        else:
-            st.error("❌ alpaca-py package NOT found!")
-            st.code(result.stderr)
+    # Try both uv and pip
+    show_commands = []
+    if uv_available:
+        show_commands.append(("uv", ["uv", "pip", "show", "alpaca-py"]))
+    show_commands.append(("pip", ["pip", "show", "alpaca-py"]))
+
+    package_info_found = False
+
+    for pm_name, pm_command in show_commands:
+        try:
+            result = subprocess.run(
+                pm_command,
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+
+            if result.returncode == 0:
+                package_info_found = True
+                st.success(f"✅ alpaca-py package details from `{pm_name}`:")
+                st.code(result.stdout)
+
+                # Try to get the version from import
+                try:
+                    import alpaca
+                    if hasattr(alpaca, "__version__"):
+                        st.info(f"📦 Alpaca version from import: {alpaca.__version__}")
+                except:
+                    pass
+
+                break  # Stop after first successful show
+
+        except subprocess.TimeoutExpired:
+            st.warning(f"`{pm_name} show` command timed out")
+        except Exception as e:
+            st.warning(f"Could not run `{pm_name} show`: {str(e)}")
+
+    if not package_info_found:
+        # Check if imports work anyway
+        try:
+            import alpaca
+            st.success("✅ Alpaca module imports successfully!")
+            if hasattr(alpaca, "__version__"):
+                st.info(f"📦 Version from import: {alpaca.__version__}")
+            if hasattr(alpaca, "__file__"):
+                st.info(f"📁 Location: {alpaca.__file__}")
+        except ImportError:
+            st.error("❌ alpaca-py package NOT installed and imports fail!")
 
             # Suggest installation
             st.markdown("### 💡 Suggested Fix")
             st.code("pip install alpaca-py>=0.20.0", language="bash")
 
-    except subprocess.TimeoutExpired:
-        st.error("pip show command timed out")
-    except Exception as e:
-        st.error(f"Error running pip show: {str(e)}")
-
     # Check requirements.txt
     st.header("📄 Requirements.txt Check")