mcli-framework 7.8.3__py3-none-any.whl → 7.8.5__py3-none-any.whl

mcli/lib/performance/__init__.py

@@ -0,0 +1,17 @@
+"""
+Performance optimization utilities for mcli
+"""
+
+from .uvloop_config import (
+    configure_event_loop_for_performance,
+    get_event_loop_info,
+    install_uvloop,
+    should_use_uvloop,
+)
+
+__all__ = [
+    "install_uvloop",
+    "should_use_uvloop",
+    "get_event_loop_info",
+    "configure_event_loop_for_performance",
+]

mcli/lib/pickles/__init__.py

@@ -0,0 +1 @@
+from .pickles import ObjectCache

mcli/lib/toml/__init__.py

@@ -0,0 +1 @@
+from .toml import read_from_toml

mcli/ml/__init__.py

@@ -0,0 +1,16 @@
+"""MCLI Machine Learning Module for Stock Recommendation System"""
+
+from .configs.dvc_config import get_dvc_config, setup_dvc
+from .configs.mlflow_config import get_mlflow_config, setup_mlflow
+from .configs.mlops_manager import MLOpsManager, get_mlops_manager
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "get_mlops_manager",
+    "MLOpsManager",
+    "get_mlflow_config",
+    "setup_mlflow",
+    "get_dvc_config",
+    "setup_dvc",
+]

mcli/ml/api/__init__.py

@@ -0,0 +1,30 @@
+"""API routes and endpoints for ML system"""
+
+from .app import create_app, get_application
+from .routers import (
+    admin_router,
+    auth_router,
+    backtest_router,
+    data_router,
+    model_router,
+    monitoring_router,
+    portfolio_router,
+    prediction_router,
+    trade_router,
+    websocket_router,
+)
+
+__all__ = [
+    "auth_router",
+    "model_router",
+    "prediction_router",
+    "portfolio_router",
+    "data_router",
+    "trade_router",
+    "backtest_router",
+    "monitoring_router",
+    "admin_router",
+    "websocket_router",
+    "create_app",
+    "get_application",
+]

mcli/ml/api/routers/__init__.py

@@ -0,0 +1,27 @@
+"""API routers"""
+
+from . import (
+    admin_router,
+    auth_router,
+    backtest_router,
+    data_router,
+    model_router,
+    monitoring_router,
+    portfolio_router,
+    prediction_router,
+    trade_router,
+    websocket_router,
+)
+
+__all__ = [
+    "auth_router",
+    "model_router",
+    "prediction_router",
+    "portfolio_router",
+    "data_router",
+    "trade_router",
+    "backtest_router",
+    "monitoring_router",
+    "admin_router",
+    "websocket_router",
+]

mcli/ml/auth/__init__.py

@@ -0,0 +1,41 @@
+"""Authentication and authorization system"""
+
+from .auth_manager import (
+    AuthManager,
+    create_access_token,
+    get_current_active_user,
+    get_current_user,
+    hash_password,
+    require_role,
+    verify_access_token,
+    verify_password,
+)
+from .models import (
+    PasswordChange,
+    PasswordReset,
+    TokenResponse,
+    UserCreate,
+    UserLogin,
+    UserResponse,
+)
+from .permissions import Permission, check_permission, has_permission
+
+__all__ = [
+    "AuthManager",
+    "create_access_token",
+    "verify_access_token",
+    "get_current_user",
+    "get_current_active_user",
+    "require_role",
+    "hash_password",
+    "verify_password",
+    "UserCreate",
+    "UserLogin",
+    "UserResponse",
+    "TokenResponse",
+    "PasswordReset",
+    "PasswordChange",
+    "Permission",
+    "check_permission",
+    "has_permission",
+]

mcli/ml/backtesting/__init__.py

@@ -0,0 +1,33 @@
+"""Backtesting framework for trading strategies"""
+
+from .backtest_engine import (
+    BacktestConfig,
+    BacktestEngine,
+    BacktestResult,
+    PositionManager,
+    TradingStrategy,
+)
+from .performance_metrics import (
+    PerformanceAnalyzer,
+    PortfolioMetrics,
+    RiskMetrics,
+    plot_performance,
+)
+from .trading_simulator import MarketSimulator, Order, Portfolio, Position, TradingSimulator
+
+__all__ = [
+    "BacktestEngine",
+    "BacktestConfig",
+    "BacktestResult",
+    "TradingStrategy",
+    "PositionManager",
+    "PerformanceAnalyzer",
+    "PortfolioMetrics",
+    "RiskMetrics",
+    "plot_performance",
+    "TradingSimulator",
+    "Order",
+    "Position",
+    "Portfolio",
+    "MarketSimulator",
+]

mcli/ml/cli/__init__.py

@@ -0,0 +1,5 @@
+"""CLI interface for ML system"""
+
+from .main import app
+
+__all__ = ["app"]

mcli/ml/config/__init__.py

@@ -0,0 +1,33 @@
+"""Configuration management for ML system"""
+
+from .settings import (
+    APISettings,
+    DatabaseSettings,
+    DataSettings,
+    MLflowSettings,
+    ModelSettings,
+    MonitoringSettings,
+    RedisSettings,
+    SecuritySettings,
+    Settings,
+    create_settings,
+    get_settings,
+    settings,
+    update_settings,
+)
+
+__all__ = [
+    "Settings",
+    "DatabaseSettings",
+    "RedisSettings",
+    "MLflowSettings",
+    "ModelSettings",
+    "DataSettings",
+    "APISettings",
+    "MonitoringSettings",
+    "SecuritySettings",
+    "settings",
+    "get_settings",
+    "update_settings",
+    "create_settings",
+]

mcli/ml/configs/__init__.py

@@ -0,0 +1,16 @@
+"""ML Configuration Module"""
+
+from .dvc_config import DVCConfig, get_dvc_config, setup_dvc
+from .mlflow_config import MLflowConfig, get_mlflow_config, setup_mlflow
+from .mlops_manager import MLOpsManager, get_mlops_manager
+
+__all__ = [
+    "MLflowConfig",
+    "get_mlflow_config",
+    "setup_mlflow",
+    "DVCConfig",
+    "get_dvc_config",
+    "setup_dvc",
+    "MLOpsManager",
+    "get_mlops_manager",
+]

mcli/ml/dashboard/__init__.py

@@ -0,0 +1,12 @@
+"""ML Dashboard for real-time monitoring"""
+
+from .app import main
+from .cli import app as cli_app
+
+
+def main():
+    """Main entry point for dashboard CLI"""
+    cli_app()
+
+
+__all__ = ["main", "cli_app"]

mcli/ml/dashboard/app_supabase.py

@@ -49,7 +49,7 @@ def get_politicians_data():
 
 @st.cache_data(ttl=30)
 def get_disclosures_data():
-    """Get trading disclosures from Supabase"""
+    """Get trading disclosures from Supabase with politician details"""
     client = get_supabase_client()
     if not client:
         return pd.DataFrame()
@@ -65,6 +65,40 @@ def get_disclosures_data():
         )
         df = pd.DataFrame(response.data)
 
+        if df.empty:
+            return df
+
+        # Get all unique politician IDs
+        politician_ids = df["politician_id"].dropna().unique()
+
+        # Fetch politician details
+        politicians = {}
+        if len(politician_ids) > 0:
+            pol_response = (
+                client.table("politicians")
+                .select("id, full_name, party, state_or_country")
+                .in_("id", list(politician_ids))
+                .execute()
+            )
+            politicians = {p["id"]: p for p in pol_response.data}
+
+        # Add politician details to disclosures
+        df["politician_name"] = df["politician_id"].map(
+            lambda x: politicians.get(x, {}).get("full_name", "Unknown")
+        )
+        df["politician_party"] = df["politician_id"].map(
+            lambda x: politicians.get(x, {}).get("party", "Unknown")
+        )
+        df["politician_state"] = df["politician_id"].map(
+            lambda x: politicians.get(x, {}).get("state_or_country", "Unknown")
+        )
+
+        # Rename columns for compatibility
+        df["ticker_symbol"] = df["asset_ticker"]
+        df["amount"] = df["amount_exact"].fillna(
+            (df["amount_range_min"] + df["amount_range_max"]) / 2
+        )
+
         # Convert datetime columns to proper datetime format
         date_columns = ["transaction_date", "disclosure_date", "created_at", "updated_at"]
         for col in date_columns:
@@ -347,21 +381,29 @@ def show_politicians():
             )
         with col2:
             state_filter = st.multiselect(
-                "State",
-                options=politicians["state"].dropna().unique() if "state" in politicians else [],
+                "State/Country",
+                options=(
+                    politicians["state_or_country"].dropna().unique()
+                    if "state_or_country" in politicians
+                    else []
+                ),
                 default=[],
             )
         with col3:
-            active_only = st.checkbox("Active Only", value=True)
+            active_only = st.checkbox("Active Only", value=False)
 
         # Apply filters
         filtered = politicians.copy()
         if party_filter and "party" in filtered:
             filtered = filtered[filtered["party"].isin(party_filter)]
-        if state_filter and "state" in filtered:
-            filtered = filtered[filtered["state"].isin(state_filter)]
-        if active_only and "is_active" in filtered:
-            filtered = filtered[filtered["is_active"] == True]
+        if state_filter and "state_or_country" in filtered:
+            filtered = filtered[filtered["state_or_country"].isin(state_filter)]
+        if active_only and "term_end" in filtered:
+            # Filter for active (term_end is in the future or null)
+            filtered = filtered[
+                (filtered["term_end"].isna())
+                | (pd.to_datetime(filtered["term_end"]) > pd.Timestamp.now())
+            ]
 
         # Display data
         st.dataframe(filtered, width="stretch")
@@ -369,17 +411,20 @@ def show_politicians():
         # Stats
         col1, col2 = st.columns(2)
         with col1:
-            if "party" in filtered:
+            if "party" in filtered and not filtered["party"].dropna().empty:
                 party_dist = filtered["party"].value_counts()
                 fig = px.pie(
                     values=party_dist.values, names=party_dist.index, title="Party Distribution"
                 )
                 st.plotly_chart(fig, width="stretch", config={"responsive": True})
         with col2:
-            if "state" in filtered:
-                state_dist = filtered["state"].value_counts().head(10)
+            if "state_or_country" in filtered and not filtered["state_or_country"].dropna().empty:
+                state_dist = filtered["state_or_country"].value_counts().head(10)
                 fig = px.bar(
-                    x=state_dist.values, y=state_dist.index, orientation="h", title="Top States"
+                    x=state_dist.values,
+                    y=state_dist.index,
+                    orientation="h",
+                    title="Top States/Countries",
                 )
                 st.plotly_chart(fig, width="stretch", config={"responsive": True})
     else:

mcli/ml/dashboard/components/__init__.py

@@ -0,0 +1,7 @@
+"""Reusable Streamlit dashboard components"""
+
+from .charts import *
+from .metrics import *
+from .tables import *
+
+__all__ = ["charts", "tables", "metrics"]

mcli/ml/dashboard/pages/__init__.py

@@ -0,0 +1,6 @@
+"""Dashboard page modules"""
+
+from .cicd import show_cicd_dashboard
+from .workflows import show_workflows_dashboard
+
+__all__ = ["show_cicd_dashboard", "show_workflows_dashboard"]

mcli/ml/dashboard/pages/predictions_enhanced.py

@@ -158,54 +158,83 @@ def generate_mock_historical_performance() -> pd.DataFrame:
 
 
 def get_real_predictions() -> pd.DataFrame:
-    """Get real predictions from ML pipeline"""
+    """Get real predictions from ML pipeline - REQUIRES SUPABASE CONNECTION"""
     if not HAS_REAL_DATA:
-        st.warning("⚠️ Supabase connection not configured. Using demo data.")
-        return generate_mock_predictions()
+        st.error("❌ **CONFIGURATION ERROR**: Real data functions not available!")
+        st.error(
+            "Cannot import Supabase utilities. Check that `src/mcli/ml/dashboard/utils.py` exists."
+        )
+        st.stop()
 
     try:
         # Get real disclosure data
         disclosures = get_disclosures_data()
 
         if disclosures.empty:
-            st.info(
-                "No disclosure data available. Click 'Run ML Pipeline' in sidebar to generate predictions."
+            st.error("❌ **DATABASE ERROR**: No trading disclosure data available!")
+            st.error("Supabase connection may not be configured. Check secrets configuration.")
+            st.code(
+                """
+# Required Streamlit Secrets:
+SUPABASE_URL = "your_supabase_url"
+SUPABASE_KEY = "your_supabase_key"
+SUPABASE_SERVICE_ROLE_KEY = "your_service_role_key"
+""",
+                language="toml",
+            )
+            st.stop()
+
+        # Check if we have enough data for ML
+        if len(disclosures) < 10:
+            st.error(
+                f"❌ **INSUFFICIENT DATA**: Found only {len(disclosures)} disclosures. "
+                f"Need at least 10 for ML predictions."
             )
-            return generate_mock_predictions()
+            st.info("Please run data collection workflows to populate the database.")
+            st.stop()
 
         # Run ML pipeline to generate predictions
-        _, _, predictions = run_ml_pipeline(disclosures)
-
-        if predictions is not None and not predictions.empty:
-            # Ensure all required columns exist
-            required_cols = [
-                "ticker",
-                "predicted_return",
-                "confidence",
-                "risk_score",
-                "recommendation",
-                "sector",
-                "politician",
-            ]
-
-            for col in required_cols:
-                if col not in predictions.columns:
-                    if col == "sector":
-                        predictions[col] = "Technology"  # Default
-                    elif col == "politician":
-                        predictions[col] = "Unknown"
-                    elif col == "ticker":
-                        predictions[col] = "UNK"
-
-            return predictions
-        else:
-            st.info("ML pipeline did not generate predictions. Using demo data for display.")
-            return generate_mock_predictions()
+        st.success(f"✅ Loaded {len(disclosures)} real trading disclosures from database!")
+
+        try:
+            _, _, predictions = run_ml_pipeline(disclosures)
+
+            if predictions is not None and not predictions.empty:
+                # Ensure all required columns exist
+                required_cols = [
+                    "ticker",
+                    "predicted_return",
+                    "confidence",
+                    "risk_score",
+                    "recommendation",
+                    "sector",
+                    "politician",
+                ]
+
+                for col in required_cols:
+                    if col not in predictions.columns:
+                        if col == "sector":
+                            predictions[col] = "Technology"  # Default
+                        elif col == "politician":
+                            predictions[col] = "Unknown"
+                        elif col == "ticker":
+                            predictions[col] = "UNK"
+
+                st.success("✅ Generated ML predictions from real data!")
+                return predictions
+            else:
+                st.error("❌ **ML PIPELINE ERROR**: Predictions returned empty!")
+                st.error("ML pipeline ran but produced no predictions.")
+                st.stop()
+        except Exception as ml_error:
+            st.error(f"❌ **ML PIPELINE ERROR**: {ml_error}")
+            st.exception(ml_error)
+            st.stop()
 
     except Exception as e:
-        st.error(f"Error loading predictions: {e}")
-        st.info("Falling back to demo data")
-        return generate_mock_predictions()
+        st.error(f"❌ **FATAL ERROR**: {e}")
+        st.exception(e)
+        st.stop()
 
 
 def show_predictions_enhanced():
@@ -659,12 +688,27 @@ def show_prediction_generator():
 
 
 def show_performance_tracker():
-    """Show prediction performance over time"""
+    """Show prediction performance over time - REQUIRES REAL ML PREDICTION HISTORY"""
 
     st.subheader("📈 Prediction Performance Tracker")
     st.markdown("Track the accuracy and ROI of our ML predictions over time")
 
-    # Generate historical data
+    # TODO: Implement real performance tracking from database
+    st.error(
+        "❌ **FEATURE NOT IMPLEMENTED**: Performance tracking requires ML prediction history database."
+    )
+    st.info(
+        """
+    This feature requires:
+    1. A prediction_history table in Supabase
+    2. Automated prediction tracking and validation
+    3. Historical performance metrics calculation
+
+    Currently showing mock data for demonstration only.
+    """
+    )
+
+    # Generate historical data (mock for now)
     performance_df = generate_mock_historical_performance()
 
     # KPIs

mcli/ml/dashboard/utils.py

@@ -69,17 +69,11 @@ 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()
+        st.warning("⚠️ Supabase connection not available. Configure SUPABASE_URL and SUPABASE_KEY.")
+        return pd.DataFrame()  # Return empty instead of demo data
 
     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
+        # Get the data with politician details joined
         response = (
             client.table("trading_disclosures")
             .select("*")
@@ -89,14 +83,48 @@ def get_disclosures_data() -> pd.DataFrame:
         )
 
         if not response.data:
-            return _generate_demo_disclosures()
+            st.info(
+                "📊 No trading disclosures found in database. Data collection may be in progress."
+            )
+            return pd.DataFrame()
 
         df = pd.DataFrame(response.data)
+
+        # Get politician details and join
+        if not df.empty and "politician_id" in df.columns:
+            politician_ids = df["politician_id"].dropna().unique()
+            if len(politician_ids) > 0:
+                pol_response = (
+                    client.table("politicians")
+                    .select("id, full_name, party, state_or_country")
+                    .in_("id", list(politician_ids))
+                    .execute()
+                )
+                politicians = {p["id"]: p for p in pol_response.data}
+
+                # Add politician details
+                df["politician_name"] = df["politician_id"].map(
+                    lambda x: politicians.get(x, {}).get("full_name", "Unknown")
+                )
+                df["politician_party"] = df["politician_id"].map(
+                    lambda x: politicians.get(x, {}).get("party", "Unknown")
+                )
+                df["politician_state"] = df["politician_id"].map(
+                    lambda x: politicians.get(x, {}).get("state_or_country", "Unknown")
+                )
+
+                # Map column names for compatibility
+                df["ticker_symbol"] = df["asset_ticker"]
+                df["amount"] = df["amount_exact"].fillna(
+                    (df["amount_range_min"] + df["amount_range_max"]) / 2
+                )
+
         return df
 
     except Exception as e:
+        st.error(f"❌ Error fetching disclosures: {e}")
         logger.error(f"Failed to fetch disclosures: {e}")
-        return _generate_demo_disclosures()
+        return pd.DataFrame()
 
 
 def _generate_demo_disclosures() -> pd.DataFrame:

mcli/ml/data_ingestion/__init__.py

@@ -0,0 +1,29 @@
+"""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",
+]