mcli-framework 7.3.1__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/predictions/monte_carlo.py

@@ -0,0 +1,428 @@
+"""Monte Carlo simulation for politician trading predictions
+
+Uses Monte Carlo methods to simulate possible price paths and estimate
+expected returns based on politician trading patterns.
+"""
+
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+logger = logging.getLogger(__name__)
+
+
+class MonteCarloTradingSimulator:
+    """Monte Carlo simulator for politician trading predictions"""
+
+    def __init__(
+        self,
+        initial_price: float,
+        days_to_simulate: int = 90,
+        num_simulations: int = 1000,
+        random_seed: Optional[int] = None,
+    ):
+        """
+        Initialize Monte Carlo simulator
+
+        Args:
+            initial_price: Starting stock price
+            days_to_simulate: Number of days to project forward
+            num_simulations: Number of Monte Carlo paths to generate
+            random_seed: Random seed for reproducibility
+        """
+        self.initial_price = initial_price
+        self.days_to_simulate = days_to_simulate
+        self.num_simulations = num_simulations
+        self.random_seed = random_seed
+
+        if random_seed is not None:
+            np.random.seed(random_seed)
+
+        # Store simulation results
+        self.simulated_paths: Optional[np.ndarray] = None
+        self.final_prices: Optional[np.ndarray] = None
+        self.returns: Optional[np.ndarray] = None
+
+    def estimate_parameters(
+        self, historical_prices: pd.Series
+    ) -> Tuple[float, float]:
+        """
+        Estimate drift (μ) and volatility (σ) from historical data
+
+        Args:
+            historical_prices: Series of historical prices
+
+        Returns:
+            Tuple of (drift, volatility)
+        """
+        # Calculate daily returns
+        returns = historical_prices.pct_change().dropna()
+
+        # Estimate parameters
+        daily_return = returns.mean()
+        daily_volatility = returns.std()
+
+        # Annualize (assuming 252 trading days)
+        annual_return = daily_return * 252
+        annual_volatility = daily_volatility * np.sqrt(252)
+
+        logger.info(
+            f"Estimated parameters: drift={annual_return:.4f}, "
+            f"volatility={annual_volatility:.4f}"
+        )
+
+        return annual_return, annual_volatility
+
+    def simulate_price_paths(
+        self, drift: float, volatility: float
+    ) -> np.ndarray:
+        """
+        Generate Monte Carlo price paths using Geometric Brownian Motion
+
+        Args:
+            drift: Expected return (μ)
+            volatility: Standard deviation (σ)
+
+        Returns:
+            Array of shape (num_simulations, days_to_simulate + 1) with price paths
+        """
+        # Time step (assuming daily)
+        dt = 1 / 252  # Daily time step in years
+
+        # Initialize price paths matrix
+        paths = np.zeros((self.num_simulations, self.days_to_simulate + 1))
+        paths[:, 0] = self.initial_price
+
+        # Generate random shocks
+        random_shocks = np.random.normal(
+            0, 1, size=(self.num_simulations, self.days_to_simulate)
+        )
+
+        # Simulate paths using Geometric Brownian Motion
+        # S(t+dt) = S(t) * exp((μ - σ²/2)dt + σ√dt * Z)
+        for t in range(1, self.days_to_simulate + 1):
+            drift_component = (drift - 0.5 * volatility**2) * dt
+            shock_component = volatility * np.sqrt(dt) * random_shocks[:, t - 1]
+
+            paths[:, t] = paths[:, t - 1] * np.exp(
+                drift_component + shock_component
+            )
+
+        self.simulated_paths = paths
+        self.final_prices = paths[:, -1]
+        self.returns = (self.final_prices - self.initial_price) / self.initial_price
+
+        logger.info(
+            f"Simulated {self.num_simulations} price paths over {self.days_to_simulate} days"
+        )
+
+        return paths
+
+    def calculate_statistics(self) -> Dict[str, float]:
+        """
+        Calculate statistics from simulation results
+
+        Returns:
+            Dictionary with statistical measures
+        """
+        if self.final_prices is None:
+            raise ValueError("Must run simulation first")
+
+        stats = {
+            "expected_final_price": np.mean(self.final_prices),
+            "median_final_price": np.median(self.final_prices),
+            "std_final_price": np.std(self.final_prices),
+            "min_final_price": np.min(self.final_prices),
+            "max_final_price": np.max(self.final_prices),
+            "expected_return": np.mean(self.returns) * 100,
+            "median_return": np.median(self.returns) * 100,
+            "std_return": np.std(self.returns) * 100,
+            "probability_profit": np.sum(self.returns > 0) / len(self.returns) * 100,
+            "value_at_risk_95": np.percentile(self.returns, 5) * 100,  # 95% VaR
+            "percentile_5": np.percentile(self.final_prices, 5),
+            "percentile_25": np.percentile(self.final_prices, 25),
+            "percentile_75": np.percentile(self.final_prices, 75),
+            "percentile_95": np.percentile(self.final_prices, 95),
+        }
+
+        return stats
+
+    def create_path_visualization(
+        self, num_paths_to_plot: int = 100, show_percentiles: bool = True
+    ) -> go.Figure:
+        """
+        Create visualization of simulated price paths
+
+        Args:
+            num_paths_to_plot: Number of individual paths to display
+            show_percentiles: Whether to show percentile bands
+
+        Returns:
+            Plotly figure object
+        """
+        if self.simulated_paths is None:
+            raise ValueError("Must run simulation first")
+
+        fig = go.Figure()
+
+        # Plot sample paths
+        num_to_plot = min(num_paths_to_plot, self.num_simulations)
+        sample_indices = np.random.choice(
+            self.num_simulations, num_to_plot, replace=False
+        )
+
+        for idx in sample_indices:
+            fig.add_trace(
+                go.Scatter(
+                    x=list(range(self.days_to_simulate + 1)),
+                    y=self.simulated_paths[idx],
+                    mode="lines",
+                    line=dict(color="lightblue", width=0.5),
+                    opacity=0.3,
+                    showlegend=False,
+                    hoverinfo="skip",
+                )
+            )
+
+        # Add mean path
+        mean_path = np.mean(self.simulated_paths, axis=0)
+        fig.add_trace(
+            go.Scatter(
+                x=list(range(self.days_to_simulate + 1)),
+                y=mean_path,
+                mode="lines",
+                line=dict(color="blue", width=3),
+                name="Expected Path",
+            )
+        )
+
+        if show_percentiles:
+            # Add percentile bands
+            percentile_5 = np.percentile(self.simulated_paths, 5, axis=0)
+            percentile_25 = np.percentile(self.simulated_paths, 25, axis=0)
+            percentile_75 = np.percentile(self.simulated_paths, 75, axis=0)
+            percentile_95 = np.percentile(self.simulated_paths, 95, axis=0)
+
+            x_vals = list(range(self.days_to_simulate + 1))
+
+            # 90% confidence band (5th to 95th percentile)
+            fig.add_trace(
+                go.Scatter(
+                    x=x_vals + x_vals[::-1],
+                    y=list(percentile_95) + list(percentile_5[::-1]),
+                    fill="toself",
+                    fillcolor="rgba(255, 0, 0, 0.1)",
+                    line=dict(color="rgba(255, 0, 0, 0)"),
+                    name="90% Confidence",
+                    hoverinfo="skip",
+                )
+            )
+
+            # 50% confidence band (25th to 75th percentile)
+            fig.add_trace(
+                go.Scatter(
+                    x=x_vals + x_vals[::-1],
+                    y=list(percentile_75) + list(percentile_25[::-1]),
+                    fill="toself",
+                    fillcolor="rgba(0, 255, 0, 0.2)",
+                    line=dict(color="rgba(0, 255, 0, 0)"),
+                    name="50% Confidence",
+                    hoverinfo="skip",
+                )
+            )
+
+        fig.update_layout(
+            title=f"Monte Carlo Simulation: {self.num_simulations:,} Price Paths",
+            xaxis_title="Days",
+            yaxis_title="Price ($)",
+            hovermode="x unified",
+            template="plotly_white",
+        )
+
+        return fig
+
+    def create_distribution_visualization(self) -> go.Figure:
+        """
+        Create histogram of final price distribution
+
+        Returns:
+            Plotly figure object
+        """
+        if self.final_prices is None:
+            raise ValueError("Must run simulation first")
+
+        stats = self.calculate_statistics()
+
+        fig = make_subplots(
+            rows=1,
+            cols=2,
+            subplot_titles=("Final Price Distribution", "Return Distribution"),
+        )
+
+        # Price distribution
+        fig.add_trace(
+            go.Histogram(
+                x=self.final_prices,
+                nbinsx=50,
+                name="Final Price",
+                marker_color="lightblue",
+                showlegend=False,
+            ),
+            row=1,
+            col=1,
+        )
+
+        # Add vertical lines for statistics
+        fig.add_vline(
+            x=stats["expected_final_price"],
+            line_dash="dash",
+            line_color="blue",
+            annotation_text="Mean",
+            row=1,
+            col=1,
+        )
+
+        fig.add_vline(
+            x=self.initial_price,
+            line_dash="solid",
+            line_color="red",
+            annotation_text="Current",
+            row=1,
+            col=1,
+        )
+
+        # Return distribution
+        fig.add_trace(
+            go.Histogram(
+                x=self.returns * 100,
+                nbinsx=50,
+                name="Returns",
+                marker_color="lightgreen",
+                showlegend=False,
+            ),
+            row=1,
+            col=2,
+        )
+
+        # Add vertical line at 0% return
+        fig.add_vline(
+            x=0, line_dash="dash", line_color="red", annotation_text="0%", row=1, col=2
+        )
+
+        fig.update_xaxes(title_text="Price ($)", row=1, col=1)
+        fig.update_xaxes(title_text="Return (%)", row=1, col=2)
+        fig.update_yaxes(title_text="Frequency", row=1, col=1)
+        fig.update_yaxes(title_text="Frequency", row=1, col=2)
+
+        fig.update_layout(
+            title="Monte Carlo Simulation Results",
+            template="plotly_white",
+            height=400,
+        )
+
+        return fig
+
+    def calculate_confidence_intervals(
+        self, confidence_levels: List[float] = [0.90, 0.95, 0.99]
+    ) -> Dict[float, Tuple[float, float]]:
+        """
+        Calculate confidence intervals for final price
+
+        Args:
+            confidence_levels: List of confidence levels (e.g., [0.90, 0.95])
+
+        Returns:
+            Dictionary mapping confidence level to (lower, upper) bounds
+        """
+        if self.final_prices is None:
+            raise ValueError("Must run simulation first")
+
+        intervals = {}
+        for level in confidence_levels:
+            alpha = 1 - level
+            lower = np.percentile(self.final_prices, alpha / 2 * 100)
+            upper = np.percentile(self.final_prices, (1 - alpha / 2) * 100)
+            intervals[level] = (lower, upper)
+
+        return intervals
+
+
+def simulate_politician_trade_impact(
+    stock_symbol: str,
+    politician_name: str,
+    transaction_amount: float,
+    historical_prices: pd.Series,
+    days_forward: int = 90,
+    num_simulations: int = 1000,
+) -> Dict:
+    """
+    Simulate potential outcomes of following a politician's trade
+
+    Args:
+        stock_symbol: Stock ticker symbol
+        politician_name: Name of politician
+        transaction_amount: Dollar amount of politician's trade
+        historical_prices: Historical price data
+        days_forward: Days to simulate forward
+        num_simulations: Number of Monte Carlo simulations
+
+    Returns:
+        Dictionary with simulation results and statistics
+    """
+    if len(historical_prices) < 30:
+        logger.warning(f"Insufficient historical data for {stock_symbol}")
+        return None
+
+    current_price = historical_prices.iloc[-1]
+
+    # Initialize simulator
+    simulator = MonteCarloTradingSimulator(
+        initial_price=current_price,
+        days_to_simulate=days_forward,
+        num_simulations=num_simulations,
+    )
+
+    # Estimate parameters from historical data
+    drift, volatility = simulator.estimate_parameters(historical_prices)
+
+    # Run simulation
+    simulator.simulate_price_paths(drift, volatility)
+
+    # Calculate statistics
+    stats = simulator.calculate_statistics()
+
+    # Create visualizations
+    path_fig = simulator.create_path_visualization(num_paths_to_plot=100)
+    dist_fig = simulator.create_distribution_visualization()
+
+    # Calculate confidence intervals
+    confidence_intervals = simulator.calculate_confidence_intervals()
+
+    return {
+        "stock_symbol": stock_symbol,
+        "politician_name": politician_name,
+        "transaction_amount": transaction_amount,
+        "current_price": current_price,
+        "simulation_days": days_forward,
+        "num_simulations": num_simulations,
+        "drift": drift,
+        "volatility": volatility,
+        "statistics": stats,
+        "confidence_intervals": confidence_intervals,
+        "path_visualization": path_fig,
+        "distribution_visualization": dist_fig,
+        "simulated_paths": simulator.simulated_paths,
+    }
+
+
+# Export main classes and functions
+__all__ = [
+    "MonteCarloTradingSimulator",
+    "simulate_politician_trade_impact",
+]

mcli/ml/trading/__init__.py

@@ -25,7 +25,11 @@ from mcli.ml.trading.models import (
     TradingSignalResponse,
 )
 from mcli.ml.trading.trading_service import TradingService
-from mcli.ml.trading.alpaca_client import AlpacaTradingClient
+from mcli.ml.trading.alpaca_client import (
+    AlpacaTradingClient,
+    create_trading_client,
+    get_alpaca_config_from_env,
+)
 from mcli.ml.trading.risk_management import RiskManager
 from mcli.ml.trading.paper_trading import PaperTradingEngine
 
@@ -55,6 +59,8 @@ __all__ = [
     # Services
     "TradingService",
     "AlpacaTradingClient",
+    "create_trading_client",
+    "get_alpaca_config_from_env",
     "RiskManager",
     "PaperTradingEngine",
 ]