mcli-framework 7.12.2__py3-none-any.whl → 7.12.4__py3-none-any.whl

mcli/ml/auth/permissions.py

@@ -1,9 +1,9 @@
-"""Permission management system"""
+"""Permission management system."""
 
 from datetime import datetime
 from enum import Enum
 from functools import wraps
-from typing import Any, Dict, List, Set
+from typing import Any, Dict, Set
 
 from fastapi import HTTPException, status
 from sqlalchemy.orm import Session
@@ -12,7 +12,7 @@ from mcli.ml.database.models import User, UserRole
 
 
 class Permission(Enum):
-    """System permissions"""
+    """System permissions."""
 
     # Model permissions
     MODEL_VIEW = "model:view"
@@ -97,13 +97,13 @@ ROLE_PERMISSIONS: Dict[UserRole, Set[Permission]] = {
 
 
 def has_permission(user: User, permission: Permission) -> bool:
-    """Check if user has specific permission"""
+    """Check if user has specific permission."""
     user_permissions = ROLE_PERMISSIONS.get(user.role, set())
     return permission in user_permissions
 
 
 def check_permission(user: User, permission: Permission) -> None:
-    """Check permission and raise exception if not allowed"""
+    """Check permission and raise exception if not allowed."""
     if not has_permission(user, permission):
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN, detail=f"Permission denied: {permission.value}"
@@ -111,7 +111,7 @@ def check_permission(user: User, permission: Permission) -> None:
 
 
 def require_permission(permission: Permission):
-    """Decorator to require specific permission"""
+    """Decorator to require specific permission."""
 
     def decorator(func):
         @wraps(func)
@@ -133,7 +133,7 @@ def require_permission(permission: Permission):
 
 
 def require_any_permission(*permissions: Permission):
-    """Decorator to require any of the specified permissions"""
+    """Decorator to require any of the specified permissions."""
 
     def decorator(func):
         @wraps(func)
@@ -159,7 +159,7 @@ def require_any_permission(*permissions: Permission):
 
 
 def require_all_permissions(*permissions: Permission):
-    """Decorator to require all of the specified permissions"""
+    """Decorator to require all of the specified permissions."""
 
     def decorator(func):
         @wraps(func)
@@ -182,7 +182,7 @@ def require_all_permissions(*permissions: Permission):
 
 
 class PermissionChecker:
-    """FastAPI dependency for permission checking"""
+    """FastAPI dependency for permission checking."""
 
     def __init__(self, permission: Permission):
         self.permission = permission
@@ -194,11 +194,11 @@ class PermissionChecker:
 
 # Resource-based permissions
 class ResourcePermission:
-    """Check permissions for specific resources"""
+    """Check permissions for specific resources."""
 
     @staticmethod
     def can_edit_portfolio(user: User, portfolio) -> bool:
-        """Check if user can edit a specific portfolio"""
+        """Check if user can edit a specific portfolio."""
         # Admin can edit any portfolio
         if user.role == UserRole.ADMIN:
             return True
@@ -211,7 +211,7 @@ class ResourcePermission:
 
     @staticmethod
     def can_view_portfolio(user: User, portfolio) -> bool:
-        """Check if user can view a specific portfolio"""
+        """Check if user can view a specific portfolio."""
         # Admin can view any portfolio
         if user.role == UserRole.ADMIN:
             return True
@@ -228,20 +228,20 @@ class ResourcePermission:
 
     @staticmethod
     def can_delete_model(user: User, model) -> bool:
-        """Check if user can delete a specific model"""
+        """Check if user can delete a specific model."""
         # Only admin can delete models
         return user.role == UserRole.ADMIN
 
     @staticmethod
     def can_deploy_model(user: User, model) -> bool:
-        """Check if user can deploy a specific model"""
+        """Check if user can deploy a specific model."""
         # Admin and Analyst can deploy models
         return user.role in [UserRole.ADMIN, UserRole.ANALYST]
 
 
 # Audit logging
 class AuditLogger:
-    """Log permission-related actions"""
+    """Log permission-related actions."""
 
     @staticmethod
     async def log_access(
@@ -252,7 +252,7 @@ class AuditLogger:
         details: Dict[str, Any] = None,
         db: Session = None,
     ):
-        """Log access attempt"""
+        """Log access attempt."""
         log_entry = {
             "user_id": str(user.id),
             "username": user.username,
@@ -269,7 +269,7 @@ class AuditLogger:
 
 # Permission groups for easier management
 class PermissionGroup:
-    """Predefined permission groups"""
+    """Predefined permission groups."""
 
     BASIC_USER = {
         Permission.MODEL_VIEW,

mcli/ml/backtesting/__init__.py

@@ -1,4 +1,4 @@
-"""Backtesting framework for trading strategies"""
+"""Backtesting framework for trading strategies."""
 
 from .backtest_engine import (
     BacktestConfig,

mcli/ml/backtesting/backtest_engine.py

@@ -1,14 +1,10 @@
-"""Backtesting engine for trading strategies"""
+"""Backtesting engine for trading strategies."""
 
-import json
 import logging
-import os
-import sys
-from dataclasses import dataclass, field
-from datetime import datetime, timedelta
+from dataclasses import dataclass
+from datetime import datetime
 from enum import Enum
-from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional
 
 import numpy as np
 import pandas as pd
@@ -19,7 +15,7 @@ logger = logging.getLogger(__name__)
 
 
 class OrderType(Enum):
-    """Order types"""
+    """Order types."""
 
     MARKET = "market"
     LIMIT = "limit"
@@ -28,7 +24,7 @@ class OrderType(Enum):
 
 
 class OrderSide(Enum):
-    """Order side"""
+    """Order side."""
 
     BUY = "buy"
     SELL = "sell"
@@ -36,7 +32,7 @@ class OrderSide(Enum):
 
 @dataclass
 class BacktestConfig:
-    """Backtesting configuration"""
+    """Backtesting configuration."""
 
     initial_capital: float = 100000.0
     start_date: Optional[datetime] = None
@@ -55,7 +51,7 @@ class BacktestConfig:
 
 @dataclass
 class BacktestResult:
-    """Backtesting results"""
+    """Backtesting results."""
 
     portfolio_value: pd.Series
     returns: pd.Series
@@ -67,7 +63,7 @@ class BacktestResult:
 
 
 class TradingStrategy:
-    """Base trading strategy class"""
+    """Base trading strategy class."""
 
     def __init__(self, model: Optional[StockRecommendationModel] = None):
         self.model = model
@@ -77,7 +73,7 @@ class TradingStrategy:
     def generate_signals(
         self, data: pd.DataFrame, current_date: datetime, portfolio_value: float
     ) -> List[Dict[str, Any]]:
-        """Generate trading signals"""
+        """Generate trading signals."""
         signals = []
 
         if self.model:
@@ -104,7 +100,7 @@ class TradingStrategy:
     def _get_model_recommendations(
         self, data: pd.DataFrame, current_date: datetime
     ) -> List[PortfolioRecommendation]:
-        """Get recommendations from ML model"""
+        """Get recommendations from ML model."""
         # Filter data up to current date
         historical_data = data[data["date"] <= current_date]
 
@@ -125,7 +121,7 @@ class TradingStrategy:
     def _momentum_strategy(
         self, data: pd.DataFrame, current_date: datetime
     ) -> List[Dict[str, Any]]:
-        """Simple momentum strategy"""
+        """Simple momentum strategy."""
         signals = []
 
         # Get recent data
@@ -163,7 +159,7 @@ class TradingStrategy:
 
 
 class PositionManager:
-    """Manage portfolio positions"""
+    """Manage portfolio positions."""
 
     def __init__(self, config: BacktestConfig):
         self.config = config
@@ -174,7 +170,7 @@ class PositionManager:
     def open_position(
         self, ticker: str, quantity: int, price: float, date: datetime, signal: Dict[str, Any]
     ):
-        """Open a new position"""
+        """Open a new position."""
         cost = quantity * price * (1 + self.config.commission + self.config.slippage)
 
         if cost > self.cash:
@@ -197,7 +193,7 @@ class PositionManager:
         return True
 
     def close_position(self, ticker: str, price: float, date: datetime) -> float:
-        """Close a position"""
+        """Close a position."""
         if ticker not in self.positions:
             return 0
 
@@ -218,7 +214,7 @@ class PositionManager:
         return realized_pnl
 
     def update_positions(self, price_data: Dict[str, float]):
-        """Update position prices and calculate unrealized PnL"""
+        """Update position prices and calculate unrealized PnL."""
         for ticker, position in self.positions.items():
             if ticker in price_data:
                 current_price = price_data[ticker]
@@ -242,7 +238,7 @@ class PositionManager:
         return None, None
 
     def get_portfolio_value(self, price_data: Dict[str, float]) -> float:
-        """Calculate total portfolio value"""
+        """Calculate total portfolio value."""
         positions_value = sum(
             pos["quantity"] * price_data.get(ticker, pos["current_price"])
             for ticker, pos in self.positions.items()
@@ -250,7 +246,7 @@ class PositionManager:
         return self.cash + positions_value
 
     def get_position_weights(self, price_data: Dict[str, float]) -> Dict[str, float]:
-        """Get position weights"""
+        """Get position weights."""
         portfolio_value = self.get_portfolio_value(price_data)
         weights = {}
 
@@ -263,7 +259,7 @@ class PositionManager:
 
 
 class BacktestEngine:
-    """Main backtesting engine"""
+    """Main backtesting engine."""
 
     def __init__(self, config: BacktestConfig):
         self.config = config
@@ -273,13 +269,13 @@ class BacktestEngine:
         self.strategy = None
 
     def set_strategy(self, strategy: TradingStrategy):
-        """Set trading strategy"""
+        """Set trading strategy."""
         self.strategy = strategy
 
     def run(
         self, price_data: pd.DataFrame, trading_data: Optional[pd.DataFrame] = None
     ) -> BacktestResult:
-        """Run backtest"""
+        """Run backtest."""
         logger.info("Starting backtest...")
 
         # Prepare data
@@ -367,12 +363,12 @@ class BacktestEngine:
     def _get_current_prices(
         self, price_data: pd.DataFrame, current_date: datetime
     ) -> Dict[str, float]:
-        """Get current prices for all tickers"""
+        """Get current prices for all tickers."""
         current_data = price_data[price_data["date"] == current_date]
         return dict(zip(current_data["symbol"], current_data["close"]))
 
     def _should_rebalance(self, day_index: int, current_date: datetime) -> bool:
-        """Check if should rebalance portfolio"""
+        """Check if should rebalance portfolio."""
         if self.config.rebalance_frequency == "daily":
             return True
         elif self.config.rebalance_frequency == "weekly":
@@ -387,7 +383,7 @@ class BacktestEngine:
         current_prices: Dict[str, float],
         current_date: datetime,
     ):
-        """Execute trading signals"""
+        """Execute trading signals."""
         for signal in signals:
             ticker = signal["ticker"]
 
@@ -402,9 +398,9 @@ class BacktestEngine:
                 position_value = portfolio_value * signal.get("position_size", 0.05)
                 quantity = int(position_value / price)
 
-                if quantity > 0:
+                if quantity > 0:  # noqa: SIM102
                     # Check if already have position
-                    if ticker not in self.position_manager.positions:
+                    if ticker not in self.position_manager.positions:  # noqa: SIM102
                         # Check max positions
                         if len(self.position_manager.positions) < self.config.max_positions:
                             success = self.position_manager.open_position(
@@ -423,7 +419,7 @@ class BacktestEngine:
                                     }
                                 )
 
-            elif signal["action"] == "sell":
+            elif signal["action"] == "sell":  # noqa: SIM102
                 if ticker in self.position_manager.positions:
                     pnl = self.position_manager.close_position(ticker, price, current_date)
 
@@ -441,7 +437,7 @@ class BacktestEngine:
                     )
 
     def _execute_exit(self, ticker: str, price: float, current_date: datetime, exit_type: str):
-        """Execute position exit"""
+        """Execute position exit."""
         if ticker in self.position_manager.positions:
             position = self.position_manager.positions[ticker]
             pnl = self.position_manager.close_position(ticker, price, current_date)
@@ -460,7 +456,7 @@ class BacktestEngine:
     def _get_position_snapshot(
         self, date: datetime, current_prices: Dict[str, float]
     ) -> Dict[str, Any]:
-        """Get current position snapshot"""
+        """Get current position snapshot."""
         snapshot = {
             "date": date,
             "num_positions": len(self.position_manager.positions),
@@ -476,7 +472,7 @@ class BacktestEngine:
         return snapshot
 
     def _calculate_metrics(self, portfolio_df: pd.DataFrame) -> Dict[str, float]:
-        """Calculate performance metrics"""
+        """Calculate performance metrics."""
         returns = portfolio_df["returns"]
 
         # Basic metrics
@@ -515,7 +511,7 @@ class BacktestEngine:
     def _get_benchmark_returns(
         self, price_data: pd.DataFrame, dates: np.ndarray
     ) -> Optional[pd.Series]:
-        """Get benchmark returns"""
+        """Get benchmark returns."""
         if self.config.benchmark not in price_data["symbol"].unique():
             return None
 

mcli/ml/backtesting/performance_metrics.py

@@ -1,21 +1,19 @@
-"""Performance metrics and analysis for backtesting"""
+"""Performance metrics and analysis for backtesting."""
 
 import logging
 from dataclasses import dataclass
-from datetime import datetime
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Dict, Optional, Tuple
 
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
-import seaborn as sns
 
 logger = logging.getLogger(__name__)
 
 
 @dataclass
 class PortfolioMetrics:
-    """Portfolio performance metrics"""
+    """Portfolio performance metrics."""
 
     total_return: float
     annualized_return: float
@@ -39,7 +37,7 @@ class PortfolioMetrics:
 
 @dataclass
 class RiskMetrics:
-    """Risk metrics"""
+    """Risk metrics."""
 
     value_at_risk_95: float
     conditional_var_95: float
@@ -56,7 +54,7 @@ class RiskMetrics:
 
 
 class PerformanceAnalyzer:
-    """Analyze backtest performance"""
+    """Analyze backtest performance."""
 
     def __init__(self, risk_free_rate: float = 0.02):
         self.risk_free_rate = risk_free_rate
@@ -67,7 +65,7 @@ class PerformanceAnalyzer:
         benchmark_returns: Optional[pd.Series] = None,
         trades: Optional[pd.DataFrame] = None,
     ) -> Tuple[PortfolioMetrics, RiskMetrics]:
-        """Calculate comprehensive performance metrics"""
+        """Calculate comprehensive performance metrics."""
 
         # Portfolio metrics
         portfolio_metrics = self._calculate_portfolio_metrics(returns, trades)
@@ -80,7 +78,7 @@ class PerformanceAnalyzer:
     def _calculate_portfolio_metrics(
         self, returns: pd.Series, trades: Optional[pd.DataFrame] = None
     ) -> PortfolioMetrics:
-        """Calculate portfolio performance metrics"""
+        """Calculate portfolio performance metrics."""
 
         # Basic returns
         total_return = (1 + returns).prod() - 1
@@ -148,7 +146,7 @@ class PerformanceAnalyzer:
     def _calculate_risk_metrics(
         self, returns: pd.Series, benchmark_returns: Optional[pd.Series] = None
     ) -> RiskMetrics:
-        """Calculate risk metrics"""
+        """Calculate risk metrics."""
 
         # Value at Risk (VaR)
         var_95 = np.percentile(returns, 5)
@@ -231,7 +229,7 @@ class PerformanceAnalyzer:
         )
 
     def _calculate_max_drawdown_duration(self, drawdown: pd.Series) -> int:
-        """Calculate maximum drawdown duration in days"""
+        """Calculate maximum drawdown duration in days."""
         is_drawdown = drawdown < 0
         drawdown_periods = []
         current_duration = 0
@@ -250,7 +248,7 @@ class PerformanceAnalyzer:
         return max(drawdown_periods) if drawdown_periods else 0
 
     def _analyze_trades(self, trades: pd.DataFrame) -> Dict[str, float]:
-        """Analyze trade statistics"""
+        """Analyze trade statistics."""
         # Filter for trades with PnL
         pnl_trades = trades[trades["pnl"].notna()].copy()
 
@@ -308,7 +306,7 @@ class PerformanceAnalyzer:
         }
 
     def _max_consecutive(self, arr: np.ndarray, value: bool) -> int:
-        """Calculate maximum consecutive occurrences of value"""
+        """Calculate maximum consecutive occurrences of value."""
         max_count = 0
         current_count = 0
 
@@ -323,7 +321,7 @@ class PerformanceAnalyzer:
 
 
 def plot_performance(backtest_result, save_path: Optional[str] = None):
-    """Plot backtest performance charts"""
+    """Plot backtest performance charts."""
     fig, axes = plt.subplots(3, 2, figsize=(15, 12))
 
     # Portfolio value

mcli/ml/backtesting/run.py

@@ -3,13 +3,12 @@
 
 import click
 
-from mcli.lib.ui.styling import error, info, success
+from mcli.lib.ui.styling import error, info
 
 
 @click.group(name="mcli-backtest", help="Backtesting CLI for MCLI trading strategies")
 def cli():
     """Main CLI group for backtesting."""
-    pass
 
 
 @cli.command(name="run", help="Run a backtest on historical data")