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

mcli/ml/tests/test_training_dashboard.py

@@ -1,7 +1,7 @@
-"""Unit tests for training dashboard functionality"""
+"""Unit tests for training dashboard functionality."""
 
 from datetime import datetime, timedelta
-from unittest.mock import MagicMock, Mock, patch
+from unittest.mock import MagicMock, Mock
 
 import numpy as np
 import pandas as pd
@@ -12,17 +12,17 @@ from mcli.ml.database.models import Experiment, Model, ModelStatus
 
 
 class TestTrainingDashboard:
-    """Test suite for training dashboard functions"""
+    """Test suite for training dashboard functions."""
 
     @pytest.fixture
     def mock_db_session(self):
-        """Create mock database session"""
+        """Create mock database session."""
         session = MagicMock(spec=Session)
         return session
 
     @pytest.fixture
     def sample_models(self):
-        """Create sample model data"""
+        """Create sample model data."""
         models = []
 
         # Bitcoin-style model comparison data
@@ -120,7 +120,7 @@ class TestTrainingDashboard:
 
     @pytest.fixture
     def sample_experiments(self):
-        """Create sample experiment data"""
+        """Create sample experiment data."""
         experiments = []
 
         for i in range(10):
@@ -147,7 +147,7 @@ class TestTrainingDashboard:
         return experiments
 
     def test_model_comparison_metrics(self, sample_models):
-        """Test model comparison metrics calculation"""
+        """Test model comparison metrics calculation."""
         # Convert to DataFrame as the dashboard would
         df = pd.DataFrame(
             [
@@ -176,7 +176,7 @@ class TestTrainingDashboard:
         assert sorted_by_mae.iloc[0]["test_mae"] < 125
 
     def test_model_performance_aggregation(self, sample_models):
-        """Test aggregation of model performance"""
+        """Test aggregation of model performance."""
         metrics = {
             "total_models": len(sample_models),
             "deployed_models": sum(1 for m in sample_models if m.status == ModelStatus.DEPLOYED),
@@ -190,7 +190,7 @@ class TestTrainingDashboard:
         assert 0.75 < metrics["avg_r2"] < 0.85
 
     def test_feature_importance_calculation(self, sample_models):
-        """Test feature importance extraction and ranking"""
+        """Test feature importance extraction and ranking."""
         model = sample_models[0]
 
         # Simulate feature importance
@@ -208,7 +208,7 @@ class TestTrainingDashboard:
         assert all(top_5["importance"] > 0)
 
     def test_residuals_analysis(self):
-        """Test residual analysis calculations"""
+        """Test residual analysis calculations."""
         # Generate sample predictions and actuals
         np.random.seed(42)
         n = 500
@@ -234,7 +234,7 @@ class TestTrainingDashboard:
         assert 0 <= p_value <= 1
 
     def test_cross_validation_metrics(self):
-        """Test cross-validation metrics calculation"""
+        """Test cross-validation metrics calculation."""
         # Simulate CV scores
         cv_scores = [0.80, 0.82, 0.78, 0.85, 0.79]
 
@@ -248,7 +248,7 @@ class TestTrainingDashboard:
         assert cv_std / cv_mean < 0.1  # Coefficient of variation < 10%
 
     def test_training_duration_analysis(self, sample_experiments):
-        """Test training duration analysis"""
+        """Test training duration analysis."""
         completed = [exp for exp in sample_experiments if exp.status == "completed"]
 
         durations = [exp.duration_seconds for exp in completed]
@@ -260,7 +260,7 @@ class TestTrainingDashboard:
         assert min_duration <= avg_duration <= max_duration
 
     def test_model_comparison_ranking(self, sample_models):
-        """Test ranking models by multiple metrics"""
+        """Test ranking models by multiple metrics."""
         df = pd.DataFrame(
             [
                 {
@@ -289,7 +289,7 @@ class TestTrainingDashboard:
         assert best_overall["test_rmse"] < 160
 
     def test_feature_categorization(self):
-        """Test feature categorization (lag, MA, volatility, etc.)"""
+        """Test feature categorization (lag, MA, volatility, etc.)."""
         features = [
             "lag_1",
             "lag_7",
@@ -329,7 +329,7 @@ class TestTrainingDashboard:
         assert len(categories["Technical"]) == 3
 
     def test_mape_calculation(self):
-        """Test Mean Absolute Percentage Error calculation"""
+        """Test Mean Absolute Percentage Error calculation."""
         actual = np.array([100, 200, 150, 300, 250])
         predicted = np.array([105, 195, 160, 295, 245])
 
@@ -339,7 +339,7 @@ class TestTrainingDashboard:
         assert mape < 10  # Should be reasonably low for good predictions
 
     def test_error_metrics_comparison(self):
-        """Test that RMSE >= MAE for any predictions"""
+        """Test that RMSE >= MAE for any predictions."""
         # This is a mathematical property: RMSE is always >= MAE
 
         errors = np.array([5, 3, 8, 2, 10])
@@ -350,7 +350,7 @@ class TestTrainingDashboard:
         assert rmse >= mae
 
     def test_r2_score_properties(self):
-        """Test R² score properties"""
+        """Test R² score properties."""
         # Perfect predictions
         y_true = np.array([1, 2, 3, 4, 5])
         y_pred = np.array([1, 2, 3, 4, 5])
@@ -369,7 +369,7 @@ class TestTrainingDashboard:
         assert r2_random < 1.0
 
     def test_experiment_status_distribution(self, sample_experiments):
-        """Test experiment status distribution"""
+        """Test experiment status distribution."""
         status_counts = {}
         for exp in sample_experiments:
             status_counts[exp.status] = status_counts.get(exp.status, 0) + 1
@@ -381,10 +381,10 @@ class TestTrainingDashboard:
 
 
 class TestModelVersioning:
-    """Test model versioning functionality"""
+    """Test model versioning functionality."""
 
     def test_version_comparison(self):
-        """Test semantic version comparison"""
+        """Test semantic version comparison."""
         versions = ["1.0.0", "1.1.0", "1.0.1", "2.0.0", "1.2.0"]
 
         # Parse and sort versions
@@ -395,7 +395,7 @@ class TestModelVersioning:
         assert sorted_versions[-1] == (2, 0, 0)
 
     def test_model_deployment_tracking(self):
-        """Test tracking which models are deployed"""
+        """Test tracking which models are deployed."""
         models = [
             {"name": "model-a", "version": "1.0.0", "deployed": True},
             {"name": "model-a", "version": "1.1.0", "deployed": False},

mcli/ml/trading/__init__.py

@@ -1,4 +1,4 @@
-"""Trading module for portfolio management and trade execution"""
+"""Trading module for portfolio management and trade execution."""
 
 from mcli.ml.trading.alpaca_client import (
     AlpacaTradingClient,

mcli/ml/trading/migrations.py

@@ -1,4 +1,4 @@
-"""Database migrations for trading functionality"""
+"""Database migrations for trading functionality."""
 
 import logging
 
@@ -12,7 +12,7 @@ logger = logging.getLogger(__name__)
 
 
 def create_trading_tables():
-    """Create trading-related tables in the database"""
+    """Create trading-related tables in the database."""
     try:
         # Get database URL from settings
         settings = get_settings()
@@ -30,7 +30,7 @@ def create_trading_tables():
 
 
 def drop_trading_tables():
-    """Drop trading-related tables from the database"""
+    """Drop trading-related tables from the database."""
     try:
         # Get database URL from settings
         settings = get_settings()
@@ -48,7 +48,7 @@ def drop_trading_tables():
 
 
 def migrate_trading_data():
-    """Migrate existing data to new trading schema"""
+    """Migrate existing data to new trading schema."""
     try:
         # Get database URL from settings
         settings = get_settings()
@@ -69,7 +69,7 @@ def migrate_trading_data():
 
 
 def verify_trading_schema():
-    """Verify that trading schema is properly set up"""
+    """Verify that trading schema is properly set up."""
     try:
         # Get database URL from settings
         settings = get_settings()

mcli/ml/trading/models.py

@@ -1,10 +1,8 @@
-"""Trading and portfolio models for the ML system"""
+"""Trading and portfolio models for the ML system."""
 
-from dataclasses import dataclass, field
 from datetime import datetime
-from decimal import Decimal
 from enum import Enum
-from typing import Any, Dict, List, Optional, Union
+from typing import List, Optional
 from uuid import UUID, uuid4
 
 from pydantic import BaseModel, Field
@@ -19,7 +17,7 @@ Base = declarative_base()
 
 
 class OrderStatus(Enum):
-    """Order status enumeration"""
+    """Order status enumeration."""
 
     PENDING = "pending"
     SUBMITTED = "submitted"
@@ -31,7 +29,7 @@ class OrderStatus(Enum):
 
 
 class OrderType(Enum):
-    """Order type enumeration"""
+    """Order type enumeration."""
 
     MARKET = "market"
     LIMIT = "limit"
@@ -41,21 +39,21 @@ class OrderType(Enum):
 
 
 class OrderSide(Enum):
-    """Order side enumeration"""
+    """Order side enumeration."""
 
     BUY = "buy"
     SELL = "sell"
 
 
 class PositionSide(Enum):
-    """Position side enumeration"""
+    """Position side enumeration."""
 
     LONG = "long"
     SHORT = "short"
 
 
 class PortfolioType(Enum):
-    """Portfolio type enumeration"""
+    """Portfolio type enumeration."""
 
     TEST = "test"
     LIVE = "live"
@@ -63,7 +61,7 @@ class PortfolioType(Enum):
 
 
 class RiskLevel(Enum):
-    """Risk level enumeration"""
+    """Risk level enumeration."""
 
     CONSERVATIVE = "conservative"
     MODERATE = "moderate"
@@ -72,7 +70,7 @@ class RiskLevel(Enum):
 
 # Database Models
 class TradingAccount(Base):
-    """Trading account information"""
+    """Trading account information."""
 
     __tablename__ = "trading_accounts"
 
@@ -103,7 +101,7 @@ class TradingAccount(Base):
 
 
 class Portfolio(Base):
-    """Portfolio information"""
+    """Portfolio information."""
 
     __tablename__ = "portfolios"
 
@@ -148,7 +146,7 @@ class Portfolio(Base):
 
 
 class Position(Base):
-    """Individual position in a portfolio"""
+    """Individual position in a portfolio."""
 
     __tablename__ = "positions"
 
@@ -186,7 +184,7 @@ class Position(Base):
 
 
 class TradingOrder(Base):
-    """Trading order information"""
+    """Trading order information."""
 
     __tablename__ = "trading_orders"
 
@@ -238,7 +236,7 @@ class TradingOrder(Base):
 
 
 class PortfolioPerformanceSnapshot(Base):
-    """Daily portfolio performance snapshots"""
+    """Daily portfolio performance snapshots."""
 
     __tablename__ = "portfolio_performance_snapshots"
 
@@ -277,7 +275,7 @@ class PortfolioPerformanceSnapshot(Base):
 
 
 class TradingSignal(Base):
-    """Trading signals generated by ML models"""
+    """Trading signals generated by ML models."""
 
     __tablename__ = "trading_signals"
 
@@ -318,7 +316,7 @@ class TradingSignal(Base):
 
 # Pydantic Models for API
 class TradingAccountCreate(BaseModel):
-    """Create trading account request"""
+    """Create trading account request."""
 
     account_name: str = Field(..., min_length=1, max_length=100)
     account_type: PortfolioType = Field(default=PortfolioType.TEST)
@@ -331,7 +329,7 @@ class TradingAccountCreate(BaseModel):
 
 
 class PortfolioCreate(BaseModel):
-    """Create portfolio request"""
+    """Create portfolio request."""
 
     name: str = Field(..., min_length=1, max_length=100)
     description: Optional[str] = None
@@ -339,7 +337,7 @@ class PortfolioCreate(BaseModel):
 
 
 class OrderCreate(BaseModel):
-    """Create order request"""
+    """Create order request."""
 
     symbol: str = Field(..., min_length=1, max_length=10)
     side: OrderSide
@@ -352,7 +350,7 @@ class OrderCreate(BaseModel):
 
 
 class PositionResponse(BaseModel):
-    """Position response model"""
+    """Position response model."""
 
     id: UUID
     symbol: str
@@ -372,7 +370,7 @@ class PositionResponse(BaseModel):
 
 
 class OrderResponse(BaseModel):
-    """Order response model"""
+    """Order response model."""
 
     id: UUID
     symbol: str
@@ -395,7 +393,7 @@ class OrderResponse(BaseModel):
 
 
 class PortfolioResponse(BaseModel):
-    """Portfolio response model"""
+    """Portfolio response model."""
 
     id: UUID
     name: str
@@ -418,7 +416,7 @@ class PortfolioResponse(BaseModel):
 
 
 class TradingSignalResponse(BaseModel):
-    """Trading signal response model"""
+    """Trading signal response model."""
 
     id: UUID
     symbol: str

mcli/ml/trading/paper_trading.py

@@ -1,9 +1,9 @@
-"""Paper trading implementation for testing portfolios without real money"""
+"""Paper trading implementation for testing portfolios without real money."""
 
 import logging
 from datetime import datetime, timedelta
 from decimal import Decimal
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, Optional
 from uuid import UUID
 
 import pandas as pd
@@ -15,6 +15,7 @@ from mcli.ml.trading.models import (
     OrderStatus,
     OrderType,
     Portfolio,
+    PortfolioCreate,
     Position,
     PositionSide,
     TradingOrder,
@@ -25,14 +26,14 @@ logger = logging.getLogger(__name__)
 
 
 class PaperTradingEngine:
-    """Paper trading engine for testing strategies without real money"""
+    """Paper trading engine for testing strategies without real money."""
 
     def __init__(self, trading_service: TradingService):
         self.trading_service = trading_service
         self.db = trading_service.db
 
     def execute_paper_order(self, order: TradingOrder) -> bool:
-        """Execute a paper trade order"""
+        """Execute a paper trade order."""
         try:
             # Get current market price
             current_price = self._get_current_price(order.symbol)
@@ -44,7 +45,9 @@ class PaperTradingEngine:
             if order.order_type == OrderType.MARKET:
                 execution_price = current_price
             elif order.order_type == OrderType.LIMIT:
-                if order.side == OrderSide.BUY and order.limit_price >= current_price:
+                if (
+                    order.side == OrderSide.BUY and order.limit_price >= current_price
+                ):  # noqa: SIM114
                     execution_price = current_price
                 elif order.side == OrderSide.SELL and order.limit_price <= current_price:
                     execution_price = current_price
@@ -80,7 +83,7 @@ class PaperTradingEngine:
             return False
 
     def _get_current_price(self, symbol: str) -> Optional[float]:
-        """Get current market price for a symbol"""
+        """Get current market price for a symbol."""
         try:
             ticker = yf.Ticker(symbol)
             data = ticker.history(period="1d", interval="1m")
@@ -92,7 +95,7 @@ class PaperTradingEngine:
             return None
 
     def _update_portfolio_positions(self, order: TradingOrder, execution_price: float):
-        """Update portfolio positions after order execution"""
+        """Update portfolio positions after order execution."""
         try:
             portfolio = self.trading_service.get_portfolio(order.portfolio_id)
             if not portfolio:
@@ -190,7 +193,7 @@ class PaperTradingEngine:
             raise
 
     def _update_portfolio_value(self, portfolio: Portfolio):
-        """Update portfolio value and metrics"""
+        """Update portfolio value and metrics."""
         try:
             # Get all positions
             positions = self.db.query(Position).filter(Position.portfolio_id == portfolio.id).all()
@@ -218,7 +221,7 @@ class PaperTradingEngine:
             raise
 
     def simulate_market_movement(self, portfolio_id: UUID, days: int = 1):
-        """Simulate market movement for paper trading"""
+        """Simulate market movement for paper trading."""
         try:
             portfolio = self.trading_service.get_portfolio(portfolio_id)
             if not portfolio:
@@ -261,7 +264,7 @@ class PaperTradingEngine:
     def create_test_portfolio(
         self, user_id: UUID, name: str = "Test Portfolio", initial_capital: float = 100000.0
     ) -> Portfolio:
-        """Create a test portfolio for paper trading"""
+        """Create a test portfolio for paper trading."""
         try:
             # Create trading account
             from mcli.ml.trading.models import TradingAccountCreate
@@ -293,7 +296,7 @@ class PaperTradingEngine:
         end_date: datetime,
         initial_capital: float = 100000.0,
     ) -> Dict:
-        """Run a backtest on historical data"""
+        """Run a backtest on historical data."""
         try:
             portfolio = self.trading_service.get_portfolio(portfolio_id)
             if not portfolio:
@@ -309,7 +312,7 @@ class PaperTradingEngine:
             self.db.query(Position).filter(Position.portfolio_id == portfolio_id).delete()
 
             # Get historical data for the period
-            date_range = pd.date_range(start=start_date, end=end_date, freq="D")
+            _date_range = pd.date_range(start=start_date, end=end_date, freq="D")  # noqa: F841
 
             # This is a simplified backtest - in practice you'd want to:
             # 1. Get historical signals
@@ -339,6 +342,6 @@ class PaperTradingEngine:
 
 
 def create_paper_trading_engine(db_session: Session) -> PaperTradingEngine:
-    """Create a paper trading engine"""
+    """Create a paper trading engine."""
     trading_service = TradingService(db_session)
     return PaperTradingEngine(trading_service)

mcli/ml/trading/risk_management.py

@@ -1,29 +1,28 @@
-"""Risk management module for trading portfolios"""
+"""Risk management module for trading portfolios."""
 
 import logging
-from datetime import datetime, timedelta
-from typing import Dict, List, Optional, Tuple
+from datetime import datetime
+from typing import Dict, List, Tuple
 from uuid import UUID
 
 import numpy as np
-import pandas as pd
 from sqlalchemy.orm import Session
 
-from mcli.ml.trading.models import Portfolio, Position, RiskLevel, TradingOrder
+from mcli.ml.trading.models import Position, RiskLevel
 from mcli.ml.trading.trading_service import TradingService
 
 logger = logging.getLogger(__name__)
 
 
 class RiskManager:
-    """Risk management system for trading portfolios"""
+    """Risk management system for trading portfolios."""
 
     def __init__(self, trading_service: TradingService):
         self.trading_service = trading_service
         self.db = trading_service.db
 
     def calculate_portfolio_risk(self, portfolio_id: UUID) -> Dict:
-        """Calculate comprehensive risk metrics for a portfolio"""
+        """Calculate comprehensive risk metrics for a portfolio."""
         try:
             portfolio = self.trading_service.get_portfolio(portfolio_id)
             if not portfolio:
@@ -60,7 +59,7 @@ class RiskManager:
             return {}
 
     def _calculate_position_risk(self, position: Position, total_market_value: float) -> Dict:
-        """Calculate risk metrics for an individual position"""
+        """Calculate risk metrics for an individual position."""
         try:
             # Position size as percentage of portfolio
             position_size_pct = (position.market_value / total_market_value) * 100
@@ -88,7 +87,7 @@ class RiskManager:
             return {}
 
     def _estimate_volatility(self, symbol: str, days: int = 30) -> float:
-        """Estimate volatility for a symbol (simplified)"""
+        """Estimate volatility for a symbol (simplified)."""
         try:
             # In practice, you would calculate historical volatility
             # For now, use a simplified approach based on market cap and sector
@@ -117,7 +116,7 @@ class RiskManager:
     def _calculate_portfolio_risk_metrics(
         self, positions: List, position_risks: List[Dict]
     ) -> Dict:
-        """Calculate portfolio-level risk metrics"""
+        """Calculate portfolio-level risk metrics."""
         try:
             if not positions or not position_risks:
                 return {}
@@ -162,7 +161,7 @@ class RiskManager:
             return {}
 
     def _estimate_beta(self, symbol: str) -> float:
-        """Estimate beta for a symbol (simplified)"""
+        """Estimate beta for a symbol (simplified)."""
         try:
             # In practice, calculate beta against market index
             # For now, use simplified estimates
@@ -186,7 +185,7 @@ class RiskManager:
             return 1.0
 
     def check_risk_limits(self, portfolio_id: UUID, new_order: Dict) -> Tuple[bool, List[str]]:
-        """Check if a new order would violate risk limits"""
+        """Check if a new order would violate risk limits."""
         try:
             portfolio = self.trading_service.get_portfolio(portfolio_id)
             if not portfolio:
@@ -215,7 +214,7 @@ class RiskManager:
 
             # Check if adding to existing position
             existing_position = next((pos for pos in positions if pos.symbol == symbol), None)
-            if existing_position:
+            if existing_position:  # noqa: SIM102
                 if side == "buy":
                     new_total_size = (
                         (existing_position.market_value + order_value)
@@ -248,7 +247,7 @@ class RiskManager:
             return False, [f"Risk check failed: {e}"]
 
     def _estimate_order_value(self, symbol: str, quantity: int) -> float:
-        """Estimate the value of an order"""
+        """Estimate the value of an order."""
         try:
             import yfinance as yf
 
@@ -269,7 +268,7 @@ class RiskManager:
         signal_strength: float,
         risk_level: RiskLevel = RiskLevel.MODERATE,
     ) -> float:
-        """Calculate recommended position size based on signal strength and risk level"""
+        """Calculate recommended position size based on signal strength and risk level."""
         try:
             portfolio = self.trading_service.get_portfolio(portfolio_id)
             if not portfolio:
@@ -303,7 +302,7 @@ class RiskManager:
             return 0.0
 
     def generate_risk_report(self, portfolio_id: UUID) -> Dict:
-        """Generate comprehensive risk report for a portfolio"""
+        """Generate comprehensive risk report for a portfolio."""
         try:
             portfolio = self.trading_service.get_portfolio(portfolio_id)
             if not portfolio:
@@ -352,7 +351,7 @@ class RiskManager:
             return {}
 
     def _generate_risk_recommendations(self, risk_metrics: Dict, max_drawdown: float) -> List[str]:
-        """Generate risk management recommendations"""
+        """Generate risk management recommendations."""
         recommendations = []
 
         # Concentration risk
@@ -386,6 +385,6 @@ class RiskManager:
 
 
 def create_risk_manager(db_session: Session) -> RiskManager:
-    """Create a risk manager instance"""
+    """Create a risk manager instance."""
     trading_service = TradingService(db_session)
     return RiskManager(trading_service)