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

mcli/ml/dashboard/utils.py

@@ -0,0 +1,154 @@
+"""Shared utility functions for dashboard pages"""
+
+import os
+import logging
+from typing import List, Optional
+import pandas as pd
+import streamlit as st
+from supabase import Client, create_client
+
+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/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",
+]

mcli/ml/experimentation/__init__.py

@@ -0,0 +1,29 @@
+"""ML Experimentation and A/B Testing Framework"""
+
+from .ab_testing import (
+    ABTestingFramework,
+    ExperimentConfig,
+    ExperimentResult,
+    ExperimentStatus,
+    Metric,
+    MetricsCollector,
+    StatisticalAnalyzer,
+    TrafficSplitter,
+    UserAssignment,
+    Variant,
+    VariantType,
+)
+
+__all__ = [
+    "ABTestingFramework",
+    "ExperimentConfig",
+    "Variant",
+    "VariantType",
+    "Metric",
+    "ExperimentStatus",
+    "ExperimentResult",
+    "UserAssignment",
+    "TrafficSplitter",
+    "MetricsCollector",
+    "StatisticalAnalyzer",
+]

mcli/ml/features/__init__.py

@@ -0,0 +1,39 @@
+"""Feature Engineering Module for Stock Recommendation Models"""
+
+from .ensemble_features import (
+    DynamicFeatureSelector,
+    EnsembleFeatureBuilder,
+    FeatureInteractionEngine,
+)
+from .political_features import (
+    CongressionalTrackingFeatures,
+    PolicyImpactFeatures,
+    PoliticalInfluenceFeatures,
+)
+from .recommendation_engine import (
+    RecommendationConfig,
+    RecommendationResult,
+    StockRecommendationEngine,
+)
+from .stock_features import (
+    CrossAssetFeatures,
+    MarketRegimeFeatures,
+    StockRecommendationFeatures,
+    TechnicalIndicatorFeatures,
+)
+
+__all__ = [
+    "StockRecommendationFeatures",
+    "TechnicalIndicatorFeatures",
+    "MarketRegimeFeatures",
+    "CrossAssetFeatures",
+    "PoliticalInfluenceFeatures",
+    "CongressionalTrackingFeatures",
+    "PolicyImpactFeatures",
+    "EnsembleFeatureBuilder",
+    "FeatureInteractionEngine",
+    "DynamicFeatureSelector",
+    "StockRecommendationEngine",
+    "RecommendationConfig",
+    "RecommendationResult",
+]

mcli/ml/mlops/__init__.py

@@ -0,0 +1,33 @@
+"""MLOps components for ML pipeline management"""
+
+from .experiment_tracker import (
+    ExperimentRun,
+    ExperimentTracker,
+    MLflowConfig,
+    ModelRegistry,
+)
+from .model_serving import (
+    ModelEndpoint,
+    ModelServer,
+    PredictionService,
+)
+from .pipeline_orchestrator import (
+    MLPipeline,
+    PipelineConfig,
+    PipelineExecutor,
+    PipelineStep,
+)
+
+__all__ = [
+    "ExperimentTracker",
+    "ModelRegistry",
+    "MLflowConfig",
+    "ExperimentRun",
+    "ModelServer",
+    "PredictionService",
+    "ModelEndpoint",
+    "MLPipeline",
+    "PipelineStep",
+    "PipelineConfig",
+    "PipelineExecutor",
+]

mcli/ml/models/__init__.py

@@ -0,0 +1,94 @@
+"""ML Models for Stock Recommendation System"""
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import torch
+
+from .base_models import (
+    BaseStockModel,
+    ModelMetrics,
+    ValidationResult,
+)
+from .ensemble_models import (
+    AttentionStockPredictor,
+    CNNFeatureExtractor,
+    DeepEnsembleModel,
+    EnsembleConfig,
+    EnsembleTrainer,
+    LSTMStockPredictor,
+    ModelConfig,
+    TransformerStockModel,
+)
+from .recommendation_models import (
+    RecommendationConfig,
+    RecommendationTrainer,
+    StockRecommendationModel,
+)
+
+# Model registry
+_loaded_models: Dict[str, Any] = {}
+
+
+async def load_production_models():
+    """Load production models into memory"""
+    from mcli.ml.config import settings
+    from mcli.ml.logging import get_logger
+
+    logger = get_logger(__name__)
+    model_dir = settings.model.model_dir
+
+    if not model_dir.exists():
+        model_dir.mkdir(parents=True, exist_ok=True)
+        return
+
+    for model_path in model_dir.glob("*.pt"):
+        try:
+            model_id = model_path.stem
+            model = torch.load(model_path, map_location=settings.model.device)
+            _loaded_models[model_id] = model
+            logger.info(f"Loaded model: {model_id}")
+        except Exception as e:
+            logger.error(f"Failed to load model {model_path}: {e}")
+
+
+async def get_model_by_id(model_id: str):
+    """Get loaded model by ID"""
+    from mcli.ml.config import settings
+
+    if model_id not in _loaded_models:
+        # Try to load from disk
+        model_path = settings.model.model_dir / f"{model_id}.pt"
+        if model_path.exists():
+            _loaded_models[model_id] = torch.load(model_path, map_location=settings.model.device)
+
+    return _loaded_models.get(model_id)
+
+
+def initialize_models():
+    """Initialize models on startup"""
+    from mcli.ml.logging import get_logger
+
+    logger = get_logger(__name__)
+    logger.info("Initializing ML models...")
+
+
+__all__ = [
+    "DeepEnsembleModel",
+    "AttentionStockPredictor",
+    "TransformerStockModel",
+    "LSTMStockPredictor",
+    "CNNFeatureExtractor",
+    "EnsembleTrainer",
+    "ModelConfig",
+    "EnsembleConfig",
+    "BaseStockModel",
+    "ModelMetrics",
+    "ValidationResult",
+    "StockRecommendationModel",
+    "RecommendationTrainer",
+    "RecommendationConfig",
+    "load_production_models",
+    "get_model_by_id",
+    "initialize_models",
+]

mcli/ml/monitoring/__init__.py

@@ -0,0 +1,25 @@
+"""ML Model Monitoring and Drift Detection"""
+
+from .drift_detection import (
+    AlertSeverity,
+    ConceptDriftDetector,
+    DataProfile,
+    DriftAlert,
+    DriftType,
+    ModelMetrics,
+    ModelMonitor,
+    OutlierDetector,
+    StatisticalDriftDetector,
+)
+
+__all__ = [
+    "ModelMonitor",
+    "StatisticalDriftDetector",
+    "ConceptDriftDetector",
+    "OutlierDetector",
+    "DriftAlert",
+    "DriftType",
+    "AlertSeverity",
+    "ModelMetrics",
+    "DataProfile",
+]

mcli/ml/optimization/__init__.py

@@ -0,0 +1,27 @@
+"""Advanced Portfolio Optimization"""
+
+from .portfolio_optimizer import (
+    AdvancedPortfolioOptimizer,
+    BaseOptimizer,
+    BlackLittermanOptimizer,
+    CVaROptimizer,
+    KellyCriterionOptimizer,
+    MeanVarianceOptimizer,
+    OptimizationConstraints,
+    OptimizationObjective,
+    PortfolioAllocation,
+    RiskParityOptimizer,
+)
+
+__all__ = [
+    "AdvancedPortfolioOptimizer",
+    "OptimizationObjective",
+    "OptimizationConstraints",
+    "PortfolioAllocation",
+    "MeanVarianceOptimizer",
+    "RiskParityOptimizer",
+    "BlackLittermanOptimizer",
+    "CVaROptimizer",
+    "KellyCriterionOptimizer",
+    "BaseOptimizer",
+]

mcli/ml/predictions/__init__.py

@@ -0,0 +1,5 @@
+"""ML Predictions Module"""
+
+from .prediction_engine import PoliticianTradingPredictor
+
+__all__ = ["PoliticianTradingPredictor"]

mcli/ml/preprocessing/__init__.py

@@ -0,0 +1,28 @@
+"""ML Data Preprocessing Module"""
+
+from .data_cleaners import (
+    MissingValueHandler,
+    OutlierDetector,
+    TradingDataCleaner,
+)
+from .feature_extractors import (
+    MarketFeatureExtractor,
+    PoliticianFeatureExtractor,
+    SentimentFeatureExtractor,
+    TemporalFeatureExtractor,
+)
+from .ml_pipeline import MLDataPipeline, MLDataPipelineConfig
+from .politician_trading_preprocessor import PoliticianTradingPreprocessor
+
+__all__ = [
+    "PoliticianTradingPreprocessor",
+    "PoliticianFeatureExtractor",
+    "MarketFeatureExtractor",
+    "TemporalFeatureExtractor",
+    "SentimentFeatureExtractor",
+    "TradingDataCleaner",
+    "OutlierDetector",
+    "MissingValueHandler",
+    "MLDataPipeline",
+    "MLDataPipelineConfig",
+]

mcli/ml/scripts/__init__.py

@@ -0,0 +1 @@
+"""ML scripts module."""

mcli/ml/trading/__init__.py

@@ -0,0 +1,60 @@
+"""Trading module for portfolio management and trade execution"""
+
+from mcli.ml.trading.models import (
+    # Enums
+    OrderStatus,
+    OrderType,
+    OrderSide,
+    PositionSide,
+    PortfolioType,
+    RiskLevel,
+    # Database models
+    TradingAccount,
+    Portfolio,
+    Position,
+    TradingOrder,
+    PortfolioPerformanceSnapshot,
+    TradingSignal,
+    # Pydantic models
+    TradingAccountCreate,
+    PortfolioCreate,
+    OrderCreate,
+    PositionResponse,
+    OrderResponse,
+    PortfolioResponse,
+    TradingSignalResponse,
+)
+from mcli.ml.trading.trading_service import TradingService
+from mcli.ml.trading.alpaca_client import AlpacaTradingClient
+from mcli.ml.trading.risk_management import RiskManager
+from mcli.ml.trading.paper_trading import PaperTradingEngine
+
+__all__ = [
+    # Enums
+    "OrderStatus",
+    "OrderType",
+    "OrderSide",
+    "PositionSide",
+    "PortfolioType",
+    "RiskLevel",
+    # Database models
+    "TradingAccount",
+    "Portfolio",
+    "Position",
+    "TradingOrder",
+    "PortfolioPerformanceSnapshot",
+    "TradingSignal",
+    # Pydantic models
+    "TradingAccountCreate",
+    "PortfolioCreate",
+    "OrderCreate",
+    "PositionResponse",
+    "OrderResponse",
+    "PortfolioResponse",
+    "TradingSignalResponse",
+    # Services
+    "TradingService",
+    "AlpacaTradingClient",
+    "RiskManager",
+    "PaperTradingEngine",
+]