mcli-framework 7.1.1__py3-none-any.whl → 7.1.3__py3-none-any.whl

mcli/ml/backtesting/performance_metrics.py

@@ -1,13 +1,14 @@
 """Performance metrics and analysis for backtesting"""
 
-import pandas as pd
-import numpy as np
-from typing import Dict, Any, Optional, List, Tuple
+import logging
 from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Tuple
+
 import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
 import seaborn as sns
-from datetime import datetime
-import logging
 
 logger = logging.getLogger(__name__)
 
@@ -15,6 +16,7 @@ logger = logging.getLogger(__name__)
 @dataclass
 class PortfolioMetrics:
     """Portfolio performance metrics"""
+
     total_return: float
     annualized_return: float
     volatility: float
@@ -38,6 +40,7 @@ class PortfolioMetrics:
 @dataclass
 class RiskMetrics:
     """Risk metrics"""
+
     value_at_risk_95: float
     conditional_var_95: float
     value_at_risk_99: float
@@ -58,9 +61,12 @@ class PerformanceAnalyzer:
     def __init__(self, risk_free_rate: float = 0.02):
         self.risk_free_rate = risk_free_rate
 
-    def calculate_metrics(self, returns: pd.Series,
-                         benchmark_returns: Optional[pd.Series] = None,
-                         trades: Optional[pd.DataFrame] = None) -> Tuple[PortfolioMetrics, RiskMetrics]:
+    def calculate_metrics(
+        self,
+        returns: pd.Series,
+        benchmark_returns: Optional[pd.Series] = None,
+        trades: Optional[pd.DataFrame] = None,
+    ) -> Tuple[PortfolioMetrics, RiskMetrics]:
         """Calculate comprehensive performance metrics"""
 
         # Portfolio metrics
@@ -71,8 +77,9 @@ class PerformanceAnalyzer:
 
         return portfolio_metrics, risk_metrics
 
-    def _calculate_portfolio_metrics(self, returns: pd.Series,
-                                    trades: Optional[pd.DataFrame] = None) -> PortfolioMetrics:
+    def _calculate_portfolio_metrics(
+        self, returns: pd.Series, trades: Optional[pd.DataFrame] = None
+    ) -> PortfolioMetrics:
         """Calculate portfolio performance metrics"""
 
         # Basic returns
@@ -84,12 +91,16 @@ class PerformanceAnalyzer:
 
         # Sharpe ratio
         excess_returns = returns - self.risk_free_rate / 252
-        sharpe_ratio = excess_returns.mean() / returns.std() * np.sqrt(252) if returns.std() > 0 else 0
+        sharpe_ratio = (
+            excess_returns.mean() / returns.std() * np.sqrt(252) if returns.std() > 0 else 0
+        )
 
         # Sortino ratio (downside deviation)
         downside_returns = returns[returns < 0]
         downside_std = downside_returns.std() * np.sqrt(252)
-        sortino_ratio = (annualized_return - self.risk_free_rate) / downside_std if downside_std > 0 else 0
+        sortino_ratio = (
+            (annualized_return - self.risk_free_rate) / downside_std if downside_std > 0 else 0
+        )
 
         # Drawdown analysis
         cumulative = (1 + returns).cumprod()
@@ -107,15 +118,15 @@ class PerformanceAnalyzer:
             trade_metrics = self._analyze_trades(trades)
         else:
             trade_metrics = {
-                'win_rate': 0.5,
-                'profit_factor': 1.0,
-                'avg_win': 0,
-                'avg_loss': 0,
-                'largest_win': 0,
-                'largest_loss': 0,
-                'consecutive_wins': 0,
-                'consecutive_losses': 0,
-                'payoff_ratio': 1.0
+                "win_rate": 0.5,
+                "profit_factor": 1.0,
+                "avg_win": 0,
+                "avg_loss": 0,
+                "largest_win": 0,
+                "largest_loss": 0,
+                "consecutive_wins": 0,
+                "consecutive_losses": 0,
+                "payoff_ratio": 1.0,
             }
 
         # Recovery factor
@@ -131,11 +142,12 @@ class PerformanceAnalyzer:
             max_drawdown=max_drawdown,
             max_drawdown_duration=max_dd_duration,
             recovery_factor=recovery_factor,
-            **trade_metrics
+            **trade_metrics,
         )
 
-    def _calculate_risk_metrics(self, returns: pd.Series,
-                               benchmark_returns: Optional[pd.Series] = None) -> RiskMetrics:
+    def _calculate_risk_metrics(
+        self, returns: pd.Series, benchmark_returns: Optional[pd.Series] = None
+    ) -> RiskMetrics:
         """Calculate risk metrics"""
 
         # Value at Risk (VaR)
@@ -149,37 +161,49 @@ class PerformanceAnalyzer:
         # Market risk metrics
         if benchmark_returns is not None and len(benchmark_returns) > 0:
             # Align series
-            aligned = pd.DataFrame({'returns': returns, 'benchmark': benchmark_returns}).dropna()
+            aligned = pd.DataFrame({"returns": returns, "benchmark": benchmark_returns}).dropna()
 
             if len(aligned) > 1:
                 # Beta
                 covariance = aligned.cov()
-                beta = covariance.loc['returns', 'benchmark'] / aligned['benchmark'].var()
+                beta = covariance.loc["returns", "benchmark"] / aligned["benchmark"].var()
 
                 # Alpha
-                alpha = aligned['returns'].mean() - beta * aligned['benchmark'].mean()
+                alpha = aligned["returns"].mean() - beta * aligned["benchmark"].mean()
                 alpha = alpha * 252  # Annualize
 
                 # Correlation
-                correlation = aligned.corr().loc['returns', 'benchmark']
+                correlation = aligned.corr().loc["returns", "benchmark"]
 
                 # Information ratio
-                active_returns = aligned['returns'] - aligned['benchmark']
+                active_returns = aligned["returns"] - aligned["benchmark"]
                 tracking_error = active_returns.std() * np.sqrt(252)
-                information_ratio = active_returns.mean() * 252 / tracking_error if tracking_error > 0 else 0
+                information_ratio = (
+                    active_returns.mean() * 252 / tracking_error if tracking_error > 0 else 0
+                )
 
                 # Treynor ratio
-                treynor_ratio = (aligned['returns'].mean() * 252 - self.risk_free_rate) / beta if beta != 0 else 0
+                treynor_ratio = (
+                    (aligned["returns"].mean() * 252 - self.risk_free_rate) / beta
+                    if beta != 0
+                    else 0
+                )
 
                 # Capture ratios
-                up_market = aligned[aligned['benchmark'] > 0]
-                down_market = aligned[aligned['benchmark'] < 0]
-
-                upside_capture = (up_market['returns'].mean() / up_market['benchmark'].mean()
-                                 if len(up_market) > 0 and up_market['benchmark'].mean() != 0 else 1.0)
-
-                downside_capture = (down_market['returns'].mean() / down_market['benchmark'].mean()
-                                   if len(down_market) > 0 and down_market['benchmark'].mean() != 0 else 1.0)
+                up_market = aligned[aligned["benchmark"] > 0]
+                down_market = aligned[aligned["benchmark"] < 0]
+
+                upside_capture = (
+                    up_market["returns"].mean() / up_market["benchmark"].mean()
+                    if len(up_market) > 0 and up_market["benchmark"].mean() != 0
+                    else 1.0
+                )
+
+                downside_capture = (
+                    down_market["returns"].mean() / down_market["benchmark"].mean()
+                    if len(down_market) > 0 and down_market["benchmark"].mean() != 0
+                    else 1.0
+                )
             else:
                 beta = alpha = correlation = information_ratio = treynor_ratio = 0
                 upside_capture = downside_capture = 1.0
@@ -203,7 +227,7 @@ class PerformanceAnalyzer:
             treynor_ratio=treynor_ratio,
             downside_deviation=downside_deviation,
             upside_capture=upside_capture,
-            downside_capture=downside_capture
+            downside_capture=downside_capture,
         )
 
     def _calculate_max_drawdown_duration(self, drawdown: pd.Series) -> int:
@@ -228,59 +252,59 @@ class PerformanceAnalyzer:
     def _analyze_trades(self, trades: pd.DataFrame) -> Dict[str, float]:
         """Analyze trade statistics"""
         # Filter for trades with PnL
-        pnl_trades = trades[trades['pnl'].notna()].copy()
+        pnl_trades = trades[trades["pnl"].notna()].copy()
 
         if len(pnl_trades) == 0:
             return {
-                'win_rate': 0.5,
-                'profit_factor': 1.0,
-                'avg_win': 0,
-                'avg_loss': 0,
-                'largest_win': 0,
-                'largest_loss': 0,
-                'consecutive_wins': 0,
-                'consecutive_losses': 0,
-                'payoff_ratio': 1.0
+                "win_rate": 0.5,
+                "profit_factor": 1.0,
+                "avg_win": 0,
+                "avg_loss": 0,
+                "largest_win": 0,
+                "largest_loss": 0,
+                "consecutive_wins": 0,
+                "consecutive_losses": 0,
+                "payoff_ratio": 1.0,
             }
 
         # Winning and losing trades
-        winning_trades = pnl_trades[pnl_trades['pnl'] > 0]
-        losing_trades = pnl_trades[pnl_trades['pnl'] < 0]
+        winning_trades = pnl_trades[pnl_trades["pnl"] > 0]
+        losing_trades = pnl_trades[pnl_trades["pnl"] < 0]
 
         # Win rate
         win_rate = len(winning_trades) / len(pnl_trades)
 
         # Average win/loss
-        avg_win = winning_trades['pnl'].mean() if len(winning_trades) > 0 else 0
-        avg_loss = abs(losing_trades['pnl'].mean()) if len(losing_trades) > 0 else 0
+        avg_win = winning_trades["pnl"].mean() if len(winning_trades) > 0 else 0
+        avg_loss = abs(losing_trades["pnl"].mean()) if len(losing_trades) > 0 else 0
 
         # Profit factor
-        gross_profit = winning_trades['pnl'].sum() if len(winning_trades) > 0 else 0
-        gross_loss = abs(losing_trades['pnl'].sum()) if len(losing_trades) > 0 else 1
+        gross_profit = winning_trades["pnl"].sum() if len(winning_trades) > 0 else 0
+        gross_loss = abs(losing_trades["pnl"].sum()) if len(losing_trades) > 0 else 1
         profit_factor = gross_profit / gross_loss if gross_loss != 0 else 0
 
         # Largest win/loss
-        largest_win = winning_trades['pnl'].max() if len(winning_trades) > 0 else 0
-        largest_loss = abs(losing_trades['pnl'].min()) if len(losing_trades) > 0 else 0
+        largest_win = winning_trades["pnl"].max() if len(winning_trades) > 0 else 0
+        largest_loss = abs(losing_trades["pnl"].min()) if len(losing_trades) > 0 else 0
 
         # Consecutive wins/losses
-        pnl_trades['is_win'] = pnl_trades['pnl'] > 0
-        consecutive_wins = self._max_consecutive(pnl_trades['is_win'].values, True)
-        consecutive_losses = self._max_consecutive(pnl_trades['is_win'].values, False)
+        pnl_trades["is_win"] = pnl_trades["pnl"] > 0
+        consecutive_wins = self._max_consecutive(pnl_trades["is_win"].values, True)
+        consecutive_losses = self._max_consecutive(pnl_trades["is_win"].values, False)
 
         # Payoff ratio
         payoff_ratio = avg_win / avg_loss if avg_loss > 0 else 0
 
         return {
-            'win_rate': win_rate,
-            'profit_factor': profit_factor,
-            'avg_win': avg_win,
-            'avg_loss': avg_loss,
-            'largest_win': largest_win,
-            'largest_loss': largest_loss,
-            'consecutive_wins': consecutive_wins,
-            'consecutive_losses': consecutive_losses,
-            'payoff_ratio': payoff_ratio
+            "win_rate": win_rate,
+            "profit_factor": profit_factor,
+            "avg_win": avg_win,
+            "avg_loss": avg_loss,
+            "largest_win": largest_win,
+            "largest_loss": largest_loss,
+            "consecutive_wins": consecutive_wins,
+            "consecutive_losses": consecutive_losses,
+            "payoff_ratio": payoff_ratio,
         }
 
     def _max_consecutive(self, arr: np.ndarray, value: bool) -> int:
@@ -304,26 +328,28 @@ def plot_performance(backtest_result, save_path: Optional[str] = None):
 
     # Portfolio value
     ax = axes[0, 0]
-    ax.plot(backtest_result.portfolio_value.index,
-            backtest_result.portfolio_value.values, label='Portfolio')
+    ax.plot(
+        backtest_result.portfolio_value.index,
+        backtest_result.portfolio_value.values,
+        label="Portfolio",
+    )
     if backtest_result.benchmark_returns is not None:
         benchmark_cumulative = (1 + backtest_result.benchmark_returns).cumprod()
         benchmark_value = benchmark_cumulative * backtest_result.portfolio_value.iloc[0]
-        ax.plot(benchmark_value.index, benchmark_value.values,
-               label='Benchmark', alpha=0.7)
-    ax.set_title('Portfolio Value')
-    ax.set_xlabel('Date')
-    ax.set_ylabel('Value ($)')
+        ax.plot(benchmark_value.index, benchmark_value.values, label="Benchmark", alpha=0.7)
+    ax.set_title("Portfolio Value")
+    ax.set_xlabel("Date")
+    ax.set_ylabel("Value ($)")
     ax.legend()
     ax.grid(True, alpha=0.3)
 
     # Returns distribution
     ax = axes[0, 1]
-    ax.hist(backtest_result.returns.values * 100, bins=50, edgecolor='black')
-    ax.set_title('Returns Distribution')
-    ax.set_xlabel('Daily Return (%)')
-    ax.set_ylabel('Frequency')
-    ax.axvline(x=0, color='red', linestyle='--', alpha=0.5)
+    ax.hist(backtest_result.returns.values * 100, bins=50, edgecolor="black")
+    ax.set_title("Returns Distribution")
+    ax.set_xlabel("Daily Return (%)")
+    ax.set_ylabel("Frequency")
+    ax.axvline(x=0, color="red", linestyle="--", alpha=0.5)
     ax.grid(True, alpha=0.3)
 
     # Drawdown
@@ -331,44 +357,45 @@ def plot_performance(backtest_result, save_path: Optional[str] = None):
     cumulative = (1 + backtest_result.returns).cumprod()
     running_max = cumulative.expanding().max()
     drawdown = ((cumulative - running_max) / running_max) * 100
-    ax.fill_between(drawdown.index, drawdown.values, 0, color='red', alpha=0.3)
-    ax.set_title('Drawdown')
-    ax.set_xlabel('Date')
-    ax.set_ylabel('Drawdown (%)')
+    ax.fill_between(drawdown.index, drawdown.values, 0, color="red", alpha=0.3)
+    ax.set_title("Drawdown")
+    ax.set_xlabel("Date")
+    ax.set_ylabel("Drawdown (%)")
     ax.grid(True, alpha=0.3)
 
     # Rolling Sharpe Ratio
     ax = axes[1, 1]
     rolling_sharpe = (
-        backtest_result.returns.rolling(window=60).mean() /
-        backtest_result.returns.rolling(window=60).std() * np.sqrt(252)
+        backtest_result.returns.rolling(window=60).mean()
+        / backtest_result.returns.rolling(window=60).std()
+        * np.sqrt(252)
     )
     ax.plot(rolling_sharpe.index, rolling_sharpe.values)
-    ax.set_title('Rolling Sharpe Ratio (60 days)')
-    ax.set_xlabel('Date')
-    ax.set_ylabel('Sharpe Ratio')
-    ax.axhline(y=0, color='red', linestyle='--', alpha=0.5)
+    ax.set_title("Rolling Sharpe Ratio (60 days)")
+    ax.set_xlabel("Date")
+    ax.set_ylabel("Sharpe Ratio")
+    ax.axhline(y=0, color="red", linestyle="--", alpha=0.5)
     ax.grid(True, alpha=0.3)
 
     # Trade analysis
     ax = axes[2, 0]
-    if not backtest_result.trades.empty and 'pnl' in backtest_result.trades.columns:
-        pnl_trades = backtest_result.trades[backtest_result.trades['pnl'].notna()]
+    if not backtest_result.trades.empty and "pnl" in backtest_result.trades.columns:
+        pnl_trades = backtest_result.trades[backtest_result.trades["pnl"].notna()]
         if not pnl_trades.empty:
-            colors = ['green' if pnl > 0 else 'red' for pnl in pnl_trades['pnl']]
-            ax.bar(range(len(pnl_trades)), pnl_trades['pnl'].values, color=colors, alpha=0.6)
-            ax.set_title('Trade PnL')
-            ax.set_xlabel('Trade Number')
-            ax.set_ylabel('PnL ($)')
-            ax.axhline(y=0, color='black', linestyle='-', alpha=0.3)
+            colors = ["green" if pnl > 0 else "red" for pnl in pnl_trades["pnl"]]
+            ax.bar(range(len(pnl_trades)), pnl_trades["pnl"].values, color=colors, alpha=0.6)
+            ax.set_title("Trade PnL")
+            ax.set_xlabel("Trade Number")
+            ax.set_ylabel("PnL ($)")
+            ax.axhline(y=0, color="black", linestyle="-", alpha=0.3)
     else:
-        ax.text(0.5, 0.5, 'No trades', ha='center', va='center')
-        ax.set_title('Trade PnL')
+        ax.text(0.5, 0.5, "No trades", ha="center", va="center")
+        ax.set_title("Trade PnL")
     ax.grid(True, alpha=0.3)
 
     # Metrics summary
     ax = axes[2, 1]
-    ax.axis('off')
+    ax.axis("off")
     metrics_text = f"""
 Performance Metrics:
 ─────────────────
@@ -380,14 +407,21 @@ Max Drawdown: {backtest_result.metrics['max_drawdown']:.2%}
 Win Rate: {backtest_result.metrics['win_rate']:.2%}
 Total Trades: {backtest_result.metrics['total_trades']}
 """
-    ax.text(0.1, 0.9, metrics_text, transform=ax.transAxes,
-            fontsize=10, verticalalignment='top', fontfamily='monospace')
+    ax.text(
+        0.1,
+        0.9,
+        metrics_text,
+        transform=ax.transAxes,
+        fontsize=10,
+        verticalalignment="top",
+        fontfamily="monospace",
+    )
 
-    plt.suptitle(f'Backtest Results - {backtest_result.strategy_name}', fontsize=14)
+    plt.suptitle(f"Backtest Results - {backtest_result.strategy_name}", fontsize=14)
     plt.tight_layout()
 
     if save_path:
-        plt.savefig(save_path, dpi=100, bbox_inches='tight')
+        plt.savefig(save_path, dpi=100, bbox_inches="tight")
         logger.info(f"Performance chart saved to {save_path}")
 
-    return fig
+    return fig

mcli/ml/cache.py

@@ -1,12 +1,12 @@
 """Redis caching layer for ML system"""
 
+import asyncio
+import hashlib
 import json
 import pickle
-import hashlib
-import asyncio
-from typing import Optional, Any, Union, Callable
-from functools import wraps
 from datetime import timedelta
+from functools import wraps
+from typing import Any, Callable, Optional, Union
 
 import redis
 from redis import asyncio as aioredis
@@ -45,8 +45,8 @@ class CacheManager:
                     port=settings.redis.port,
                     db=settings.redis.db,
                     password=settings.redis.password,
-                    max_connections=settings.redis.max_connections
-                )
+                    max_connections=settings.redis.max_connections,
+                ),
             )
 
             # Test connection
@@ -68,7 +68,7 @@ class CacheManager:
                 settings.redis.url,
                 encoding="utf-8",
                 decode_responses=False,
-                max_connections=settings.redis.max_connections
+                max_connections=settings.redis.max_connections,
             )
 
             # Test connection
@@ -88,7 +88,7 @@ class CacheManager:
         try:
             # Try JSON first (for simple types)
             if isinstance(value, (dict, list, str, int, float, bool, type(None))):
-                return json.dumps(value).encode('utf-8')
+                return json.dumps(value).encode("utf-8")
         except:
             pass
 
@@ -102,7 +102,7 @@ class CacheManager:
 
         # Try JSON first
         try:
-            return json.loads(value.decode('utf-8'))
+            return json.loads(value.decode("utf-8"))
         except:
             pass
 
@@ -272,10 +272,7 @@ def cached(expire: int = 3600, key_prefix: str = None):
                 key_parts.insert(0, key_prefix)
 
             # Add function arguments to key
-            key_data = {
-                'args': args,
-                'kwargs': kwargs
-            }
+            key_data = {"args": args, "kwargs": kwargs}
             key_hash = hashlib.md5(
                 json.dumps(key_data, sort_keys=True, default=str).encode()
             ).hexdigest()
@@ -306,10 +303,7 @@ def cached(expire: int = 3600, key_prefix: str = None):
             if key_prefix:
                 key_parts.insert(0, key_prefix)
 
-            key_data = {
-                'args': args,
-                'kwargs': kwargs
-            }
+            key_data = {"args": args, "kwargs": kwargs}
             key_hash = hashlib.md5(
                 json.dumps(key_data, sort_keys=True, default=str).encode()
             ).hexdigest()
@@ -397,4 +391,4 @@ def cache_get(key: str):
 
 def cache_delete(key: str):
     """Delete cache entry"""
-    return cache_manager.delete(key)
+    return cache_manager.delete(key)

mcli/ml/cli/main.py

@@ -1,25 +1,29 @@
 """Main CLI interface for ML system"""
 
-import typer
 import asyncio
 from pathlib import Path
-from typing import Optional, List
+from typing import List, Optional
+
+import typer
 from rich.console import Console
-from rich.table import Table
 from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
 
-from mcli.ml.config import settings, create_settings
+from mcli.ml.backtesting.backtest_engine import BacktestConfig, BacktestEngine
+from mcli.ml.config import create_settings, settings
+from mcli.ml.experimentation.ab_testing import ABTestingFramework
 from mcli.ml.mlops.pipeline_orchestrator import MLPipeline, PipelineConfig
-from mcli.ml.backtesting.backtest_engine import BacktestEngine, BacktestConfig
-from mcli.ml.optimization.portfolio_optimizer import AdvancedPortfolioOptimizer, OptimizationObjective
 from mcli.ml.monitoring.drift_detection import ModelMonitor
-from mcli.ml.experimentation.ab_testing import ABTestingFramework
+from mcli.ml.optimization.portfolio_optimizer import (
+    AdvancedPortfolioOptimizer,
+    OptimizationObjective,
+)
 
 app = typer.Typer(
     name="mcli-ml",
     help="ML system for politician trading analysis and stock recommendations",
     no_args_is_help=True,
-    rich_markup_mode="rich"
+    rich_markup_mode="rich",
 )
 
 console = Console()
@@ -33,7 +37,9 @@ def train(
     batch_size: Optional[int] = typer.Option(None, "--batch-size", help="Training batch size"),
     learning_rate: Optional[float] = typer.Option(None, "--lr", help="Learning rate"),
     device: Optional[str] = typer.Option(None, "--device", help="Device (cpu, cuda, auto)"),
-    dry_run: bool = typer.Option(False, "--dry-run", help="Validate configuration without training"),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Validate configuration without training"
+    ),
 ):
     """Train ML models for stock recommendations"""
 
@@ -82,12 +88,12 @@ def train(
                 console.print(f"Model saved to: {result.get('model_path', 'Unknown')}")
 
                 # Display metrics if available
-                if 'metrics' in result:
+                if "metrics" in result:
                     metrics_table = Table(title="Training Metrics")
                     metrics_table.add_column("Metric", style="cyan")
                     metrics_table.add_column("Value", style="magenta")
 
-                    for metric, value in result['metrics'].items():
+                    for metric, value in result["metrics"].items():
                         metrics_table.add_row(metric, str(value))
 
                     console.print(metrics_table)
@@ -116,6 +122,7 @@ def serve(
     console.print(f"Workers: {workers}")
 
     import uvicorn
+
     from mcli.ml.mlops.model_serving import app as serving_app
 
     uvicorn.run(
@@ -146,7 +153,7 @@ def backtest(
     config = BacktestConfig(
         initial_capital=initial_capital,
         commission=commission,
-        benchmark='SPY',
+        benchmark="SPY",
     )
 
     async def run_backtest():
@@ -162,7 +169,9 @@ def backtest(
             try:
                 # In a real implementation, you'd load actual price data
                 # For now, we'll just validate the setup
-                console.print("[yellow]Note: This is a demo setup. Connect to actual data sources for real backtesting.[/yellow]")
+                console.print(
+                    "[yellow]Note: This is a demo setup. Connect to actual data sources for real backtesting.[/yellow]"
+                )
 
                 progress.update(task, description="Backtest completed!")
                 console.print("[green]✓ Backtest completed successfully![/green]")
@@ -204,7 +213,9 @@ def optimize(
         obj_enum = OptimizationObjective(objective)
     except ValueError:
         console.print(f"[red]Invalid objective: {objective}[/red]")
-        console.print(f"Valid objectives: {', '.join([obj.value for obj in OptimizationObjective])}")
+        console.print(
+            f"Valid objectives: {', '.join([obj.value for obj in OptimizationObjective])}"
+        )
         raise typer.Exit(1)
 
     async def run_optimization():
@@ -217,7 +228,9 @@ def optimize(
 
             try:
                 # In a real implementation, you'd fetch actual returns and covariance
-                console.print("[yellow]Note: Using sample data for demo. Connect to data sources for real optimization.[/yellow]")
+                console.print(
+                    "[yellow]Note: Using sample data for demo. Connect to data sources for real optimization.[/yellow]"
+                )
 
                 progress.update(task, description="Optimization completed!")
                 console.print("[green]✓ Portfolio optimization completed![/green]")
@@ -228,7 +241,7 @@ def optimize(
                 allocation_table.add_column("Weight", style="magenta")
 
                 # Sample allocation
-                weights = [0.35, 0.30, 0.25, 0.10][:len(tickers)]
+                weights = [0.35, 0.30, 0.25, 0.10][: len(tickers)]
                 for ticker, weight in zip(tickers, weights):
                     allocation_table.add_row(ticker, f"{weight:.1%}")
 
@@ -267,7 +280,9 @@ def monitor(
     monitor = ModelMonitor(model_name)
 
     if check_drift:
-        console.print("[yellow]Note: Connect to real data sources for actual drift detection.[/yellow]")
+        console.print(
+            "[yellow]Note: Connect to real data sources for actual drift detection.[/yellow]"
+        )
         console.print("[green]✓ No significant drift detected[/green]")
 
     if generate_report:
@@ -311,16 +326,15 @@ def experiment(
 
         for exp in experiments:
             exp_table.add_row(
-                exp["id"][:8] + "...",
-                exp["name"],
-                exp["status"],
-                str(exp["variants"])
+                exp["id"][:8] + "...", exp["name"], exp["status"], str(exp["variants"])
             )
 
         console.print(exp_table)
 
     else:
-        console.print(f"[yellow]Action '{action}' would be executed for experiment {experiment_id or 'N/A'}[/yellow]")
+        console.print(
+            f"[yellow]Action '{action}' would be executed for experiment {experiment_id or 'N/A'}[/yellow]"
+        )
 
 
 @app.command()
@@ -395,4 +409,4 @@ def config(
 
 
 if __name__ == "__main__":
-    app()
+    app()