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

mcli/ml/database/session.py

@@ -13,9 +13,121 @@ from mcli.ml.config import settings
 from .models import Base
 
 # Synchronous database setup
+# Prioritize DATABASE_URL environment variable over settings
+import os
+database_url = os.getenv("DATABASE_URL")
+
+# Check if DATABASE_URL has placeholder password
+if database_url and "your_password" in database_url:
+    database_url = None  # Treat placeholder as not set
+
+# If no DATABASE_URL or it's SQLite from settings, try explicit configuration
+if not database_url:
+    try:
+        # Check if settings has a non-SQLite configuration
+        settings_url = settings.database.url
+        if settings_url and "sqlite" not in settings_url:
+            database_url = settings_url
+    except (AttributeError, Exception):
+        pass  # Continue with database_url=None
+
+# If still no valid DATABASE_URL, try to use Supabase REST API via connection pooler
+if not database_url:
+    supabase_url = os.getenv("SUPABASE_URL", "")
+    supabase_service_key = os.getenv("SUPABASE_SERVICE_ROLE_KEY")
+
+    if supabase_url and supabase_service_key and "supabase.co" in supabase_url:
+        # Extract project reference from Supabase URL
+        # Format: https://PROJECT_REF.supabase.co
+        project_ref = supabase_url.replace("https://", "").replace("http://", "").split(".")[0]
+
+        # Use Supabase IPv4-only connection pooler
+        # This avoids IPv6 connectivity issues on Streamlit Cloud
+        # Try EU region poolers (which are verified to work for this project)
+        # Session mode (port 5432) for persistent connections
+        # Transaction mode (port 6543) for serverless/short-lived connections
+        pooler_urls = [
+            f"postgresql://postgres.{project_ref}:{supabase_service_key}@aws-1-eu-north-1.pooler.supabase.com:5432/postgres",
+            f"postgresql://postgres.{project_ref}:{supabase_service_key}@aws-1-eu-north-1.pooler.supabase.com:6543/postgres",
+        ]
+
+        # Try to connect to poolers
+        import logging
+        logger = logging.getLogger(__name__)
+
+        for pooler_url in pooler_urls:
+            try:
+                # Test connection
+                test_engine = create_engine(pooler_url, pool_pre_ping=True)
+                with test_engine.connect() as conn:
+                    from sqlalchemy import text
+                    conn.execute(text("SELECT 1"))
+                database_url = pooler_url
+                logger.info(f"Successfully connected via pooler: {pooler_url.split('@')[1].split(':')[0]}")
+                test_engine.dispose()
+                break
+            except Exception as e:
+                logger.warning(f"Failed to connect via {pooler_url.split('@')[1].split(':')[0]}: {e}")
+                continue
+
+        if not database_url:
+            # Fallback to first pooler URL if all fail (will be handled by pool_pre_ping later)
+            database_url = pooler_urls[0]
+
+        import warnings
+        warnings.warn(
+            "Using Supabase connection pooler with service role key. "
+            "For better performance, set DATABASE_URL with your actual database password. "
+            "Find it in Supabase Dashboard → Settings → Database → Connection String"
+        )
+    else:
+        # Default to SQLite for development/testing
+        database_url = "sqlite:///./ml_system.db"
+        import warnings
+        warnings.warn(
+            "No database credentials found. Using SQLite fallback. "
+            "Set SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY or DATABASE_URL in environment."
+        )
+
+# Debug: Log which database URL is being used
+import logging
+logger = logging.getLogger(__name__)
+
+if "pooler.supabase.com" in database_url:
+    logger.info(f"🔗 Using Supabase connection pooler")
+elif "sqlite" in database_url:
+    logger.warning("📁 Using SQLite fallback (database features limited)")
+else:
+    # Mask password in display
+    display_url = database_url
+    if "@" in display_url and ":" in display_url:
+        parts = display_url.split("@")
+        before_at = parts[0].split(":")
+        if len(before_at) >= 3:
+            before_at[2] = "***"
+            display_url = ":".join(before_at) + "@" + parts[1]
+    logger.info(f"🔗 Database URL: {display_url}")
+
+# Configure connection arguments based on database type
+if "sqlite" in database_url:
+    connect_args = {"check_same_thread": False}
+elif "postgresql" in database_url:
+    # Force IPv4 for PostgreSQL to avoid IPv6 connection issues
+    connect_args = {
+        "connect_timeout": 10,
+        "options": "-c statement_timeout=30000",  # 30 second query timeout
+    }
+else:
+    connect_args = {}
+
 engine = create_engine(
-    settings.database.url,
-    **settings.get_database_config(),
+    database_url,
+    connect_args=connect_args,
+    pool_pre_ping=True,  # Verify connections before using them
+    pool_recycle=3600,  # Recycle connections after 1 hour
+    pool_size=5,  # Smaller pool for Streamlit Cloud
+    max_overflow=10,
+    pool_timeout=30,
 )
 
 SessionLocal = sessionmaker(
@@ -27,14 +139,30 @@ SessionLocal = sessionmaker(
 
 
 # Asynchronous database setup
-async_engine = create_async_engine(
-    settings.database.async_url,
-    pool_size=settings.database.pool_size,
-    max_overflow=settings.database.max_overflow,
-    pool_timeout=settings.database.pool_timeout,
-    pool_pre_ping=True,
-    echo=settings.debug,
-)
+try:
+    async_engine = create_async_engine(
+        settings.database.async_url,
+        pool_size=settings.database.pool_size,
+        max_overflow=settings.database.max_overflow,
+        pool_timeout=settings.database.pool_timeout,
+        pool_pre_ping=True,
+        echo=settings.debug,
+    )
+except (AttributeError, Exception):
+    # Fallback for async engine
+    import os
+    async_database_url = os.getenv("ASYNC_DATABASE_URL")
+    if not async_database_url:
+        # Convert sync URL to async if possible
+        if "sqlite" in database_url:
+            async_database_url = database_url.replace("sqlite:///", "sqlite+aiosqlite:///")
+        else:
+            async_database_url = database_url.replace("postgresql://", "postgresql+asyncpg://")
+
+    async_engine = create_async_engine(
+        async_database_url,
+        pool_pre_ping=True,
+    )
 
 AsyncSessionLocal = async_sessionmaker(
     async_engine,
@@ -81,21 +209,46 @@ async def get_async_db() -> AsyncGenerator[AsyncSession, None]:
 @contextmanager
 def get_session() -> Generator[Session, None, None]:
     """
-    Context manager for database session.
+    Context manager for database session with improved error handling.
 
     Usage:
         with get_session() as session:
             user = session.query(User).first()
+
+    Raises:
+        ConnectionError: If database connection cannot be established
+        Exception: For other database errors
     """
-    session = SessionLocal()
+    session = None
     try:
+        session = SessionLocal()
+        # Test the connection
+        from sqlalchemy import text
+        session.execute(text("SELECT 1"))
         yield session
         session.commit()
-    except Exception:
-        session.rollback()
-        raise
+    except Exception as e:
+        if session:
+            session.rollback()
+        # Provide more helpful error messages
+        error_msg = str(e).lower()
+        if "cannot assign requested address" in error_msg or "ipv6" in error_msg:
+            raise ConnectionError(
+                "Database connection failed due to network issues. "
+                "This may be an IPv6 connectivity problem. "
+                "Please ensure DATABASE_URL uses connection pooler (pooler.supabase.com) instead of direct connection (db.supabase.co). "
+                f"Original error: {e}"
+            )
+        elif "authentication failed" in error_msg or "password" in error_msg:
+            raise ConnectionError(
+                "Database authentication failed. Please check your database credentials. "
+                f"Original error: {e}"
+            )
+        else:
+            raise
     finally:
-        session.close()
+        if session:
+            session.close()
 
 
 @asynccontextmanager

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"]