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

mcli/ml/models/test_models.py

@@ -1,4 +1,4 @@
-"""Test script for ensemble models"""
+"""Test script for ensemble models."""
 
 import os
 import sys
@@ -6,7 +6,6 @@ import sys
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../../.."))
 
 import logging
-from datetime import datetime, timedelta
 
 import numpy as np
 import pandas as pd
@@ -18,7 +17,7 @@ logger = logging.getLogger(__name__)
 
 
 def generate_mock_features(n_samples: int = 500, n_features: int = 150) -> pd.DataFrame:
-    """Generate mock feature data for testing"""
+    """Generate mock feature data for testing."""
     np.random.seed(42)
 
     # Create realistic feature names
@@ -50,7 +49,7 @@ def generate_mock_features(n_samples: int = 500, n_features: int = 150) -> pd.Da
 
     # Generate correlated features that simulate real market data
     features = []
-    for i in range(n_samples):
+    for _i in range(n_samples):
         # Base market trend
         market_trend = np.random.normal(0, 1)
 
@@ -85,7 +84,7 @@ def generate_mock_features(n_samples: int = 500, n_features: int = 150) -> pd.Da
 
 
 def generate_mock_targets(n_samples: int) -> tuple:
-    """Generate realistic target variables"""
+    """Generate realistic target variables."""
     np.random.seed(42)
 
     # Generate correlated targets
@@ -104,7 +103,7 @@ def generate_mock_targets(n_samples: int) -> tuple:
 
 
 def test_base_models():
-    """Test base model functionality"""
+    """Test base model functionality."""
     logger.info("Testing base models...")
 
     from base_models import MLPBaseModel, ResNetModel
@@ -122,7 +121,7 @@ def test_base_models():
     logger.info(f"MLP output shape: {output.shape}")
 
     # Test prediction
-    probas = mlp_model.predict_proba(X)
+    mlp_model.predict_proba(X)
     predictions = mlp_model.predict(X)
     logger.info(f"MLP predictions shape: {predictions.shape}")
 
@@ -140,7 +139,7 @@ def test_base_models():
 
 
 def test_ensemble_models():
-    """Test ensemble model functionality"""
+    """Test ensemble model functionality."""
     logger.info("Testing ensemble models...")
 
     from ensemble_models import (
@@ -233,7 +232,7 @@ def test_ensemble_models():
     logger.info(f"Individual predictions: {len(individual_preds)} models")
 
     # Test prediction methods
-    ensemble_probas = ensemble_model.predict_proba(X.values[:20])
+    _ensemble_probas = ensemble_model.predict_proba(X.values[:20])  # noqa: F841
     ensemble_preds = ensemble_model.predict(X.values[:20])
     logger.info(f"Ensemble predictions shape: {ensemble_preds.shape}")
 
@@ -241,14 +240,13 @@ def test_ensemble_models():
 
 
 def test_recommendation_model():
-    """Test recommendation model"""
+    """Test recommendation model."""
     logger.info("Testing recommendation model...")
 
     from ensemble_models import EnsembleConfig, ModelConfig
     from recommendation_models import (
         PortfolioRecommendation,
         RecommendationConfig,
-        RecommendationTrainer,
         StockRecommendationModel,
     )
 
@@ -329,7 +327,7 @@ def test_recommendation_model():
 
 
 def test_model_training():
-    """Test model training functionality"""
+    """Test model training functionality."""
     logger.info("Testing model training...")
 
     from ensemble_models import EnsembleConfig, EnsembleTrainer, ModelConfig
@@ -376,7 +374,7 @@ def test_model_training():
     logger.info("Training ensemble model...")
     ensemble_result = ensemble_trainer.train(X_train.values, y_train, X_val.values, y_val)
 
-    logger.info(f"Ensemble training metrics:")
+    logger.info("Ensemble training metrics:")
     logger.info(f"  Train accuracy: {ensemble_result.train_metrics.accuracy:.3f}")
     logger.info(f"  Val accuracy: {ensemble_result.val_metrics.accuracy:.3f}")
 
@@ -398,7 +396,7 @@ def test_model_training():
         batch_size=32,
     )
 
-    logger.info(f"Recommendation training metrics:")
+    logger.info("Recommendation training metrics:")
     logger.info(f"  Train accuracy: {rec_result.train_metrics.accuracy:.3f}")
     logger.info(f"  Val accuracy: {rec_result.val_metrics.accuracy:.3f}")
 
@@ -413,7 +411,7 @@ def test_model_training():
 
 
 def test_model_persistence():
-    """Test model saving and loading"""
+    """Test model saving and loading."""
     logger.info("Testing model persistence...")
 
     import tempfile
@@ -450,7 +448,7 @@ def test_model_persistence():
 
 
 def main():
-    """Run all model tests"""
+    """Run all model tests."""
     logger.info("Starting ensemble model tests...")
 
     try:

mcli/ml/monitoring/__init__.py

@@ -1,4 +1,4 @@
-"""ML Model Monitoring and Drift Detection"""
+"""ML Model Monitoring and Drift Detection."""
 
 from .drift_detection import (
     AlertSeverity,

mcli/ml/monitoring/drift_detection.py

@@ -1,22 +1,18 @@
-"""Model monitoring and drift detection for ML systems"""
+"""Model monitoring and drift detection for ML systems."""
 
-import asyncio
 import json
 import logging
 import pickle
-import warnings
 from dataclasses import asdict, dataclass, field
 from datetime import datetime, timedelta
 from enum import Enum
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, List, Optional
 
 import numpy as np
 import pandas as pd
-from scipy import stats
 from sklearn.ensemble import IsolationForest
 from sklearn.metrics import ks_2samp
-from sklearn.model_selection import train_test_split
 
 logger = logging.getLogger(__name__)
 
@@ -37,7 +33,7 @@ class AlertSeverity(Enum):
 
 @dataclass
 class DriftAlert:
-    """Drift detection alert"""
+    """Drift detection alert."""
 
     timestamp: datetime
     drift_type: DriftType
@@ -51,7 +47,7 @@ class DriftAlert:
 
 @dataclass
 class ModelMetrics:
-    """Model performance metrics"""
+    """Model performance metrics."""
 
     timestamp: datetime
     accuracy: float
@@ -67,7 +63,7 @@ class ModelMetrics:
 
 @dataclass
 class DataProfile:
-    """Statistical profile of data"""
+    """Statistical profile of data."""
 
     feature_means: Dict[str, float]
     feature_stds: Dict[str, float]
@@ -79,7 +75,7 @@ class DataProfile:
 
 
 class StatisticalDriftDetector:
-    """Detect statistical drift in data distributions"""
+    """Detect statistical drift in data distributions."""
 
     def __init__(
         self, reference_data: pd.DataFrame, significance_level: float = 0.05, min_samples: int = 100
@@ -90,7 +86,7 @@ class StatisticalDriftDetector:
         self.min_samples = min_samples
 
     def detect_drift(self, current_data: pd.DataFrame) -> Dict[str, Any]:
-        """Detect drift between reference and current data"""
+        """Detect drift between reference and current data."""
         if len(current_data) < self.min_samples:
             return {"drift_detected": False, "message": "Insufficient samples"}
 
@@ -138,7 +134,7 @@ class StatisticalDriftDetector:
         return drift_results
 
     def _create_data_profile(self, data: pd.DataFrame) -> DataProfile:
-        """Create statistical profile of data"""
+        """Create statistical profile of data."""
         numeric_data = data.select_dtypes(include=[np.number])
 
         return DataProfile(
@@ -156,7 +152,7 @@ class StatisticalDriftDetector:
     def _calculate_psi(
         self, reference_data: pd.DataFrame, current_data: pd.DataFrame
     ) -> Dict[str, float]:
-        """Calculate Population Stability Index for each feature"""
+        """Calculate Population Stability Index for each feature."""
         psi_scores = {}
 
         for feature in reference_data.columns:
@@ -173,7 +169,7 @@ class StatisticalDriftDetector:
         return psi_scores
 
     def _psi_score(self, reference: pd.Series, current: pd.Series, bins: int = 10) -> float:
-        """Calculate PSI score between two distributions"""
+        """Calculate PSI score between two distributions."""
         try:
             # Create bins based on reference data
             ref_min, ref_max = reference.min(), reference.max()
@@ -203,7 +199,7 @@ class StatisticalDriftDetector:
     def _compare_feature_distributions(
         self, ref_profile: DataProfile, curr_profile: DataProfile
     ) -> Dict[str, Dict[str, float]]:
-        """Compare feature distributions between profiles"""
+        """Compare feature distributions between profiles."""
         comparisons = {}
 
         for feature in ref_profile.feature_means.keys():
@@ -231,7 +227,7 @@ class StatisticalDriftDetector:
 
 
 class ConceptDriftDetector:
-    """Detect concept drift in model predictions"""
+    """Detect concept drift in model predictions."""
 
     def __init__(self, window_size: int = 1000, detection_threshold: float = 0.05):
         self.window_size = window_size
@@ -239,7 +235,7 @@ class ConceptDriftDetector:
         self.historical_metrics = []
 
     def add_batch_metrics(self, metrics: ModelMetrics):
-        """Add batch metrics for drift detection"""
+        """Add batch metrics for drift detection."""
         self.historical_metrics.append(metrics)
 
         # Keep only recent metrics
@@ -247,7 +243,7 @@ class ConceptDriftDetector:
             self.historical_metrics = self.historical_metrics[-self.window_size :]
 
     def detect_concept_drift(self) -> Dict[str, Any]:
-        """Detect concept drift using model performance degradation"""
+        """Detect concept drift using model performance degradation."""
         if len(self.historical_metrics) < self.window_size:
             return {"drift_detected": False, "message": "Insufficient historical data"}
 
@@ -292,7 +288,7 @@ class ConceptDriftDetector:
         }
 
     def _calculate_average_performance(self, metrics_list: List[ModelMetrics]) -> Dict[str, float]:
-        """Calculate average performance metrics"""
+        """Calculate average performance metrics."""
         if not metrics_list:
             return {}
 
@@ -312,7 +308,7 @@ class ConceptDriftDetector:
 
 
 class OutlierDetector:
-    """Detect outliers in incoming data"""
+    """Detect outliers in incoming data."""
 
     def __init__(self, contamination: float = 0.1):
         self.contamination = contamination
@@ -320,7 +316,7 @@ class OutlierDetector:
         self.is_fitted = False
 
     def fit(self, reference_data: pd.DataFrame):
-        """Fit outlier detector on reference data"""
+        """Fit outlier detector on reference data."""
         numeric_data = reference_data.select_dtypes(include=[np.number])
 
         if numeric_data.empty:
@@ -332,7 +328,7 @@ class OutlierDetector:
         self.is_fitted = True
 
     def detect_outliers(self, data: pd.DataFrame) -> Dict[str, Any]:
-        """Detect outliers in new data"""
+        """Detect outliers in new data."""
         if not self.is_fitted:
             return {"outliers_detected": False, "message": "Detector not fitted"}
 
@@ -358,7 +354,7 @@ class OutlierDetector:
 
 
 class ModelMonitor:
-    """Comprehensive model monitoring system"""
+    """Comprehensive model monitoring system."""
 
     def __init__(self, model_name: str, storage_path: Path = Path("monitoring")):
         self.model_name = model_name
@@ -385,7 +381,7 @@ class ModelMonitor:
         self.monitoring_history = []
 
     def setup_reference_data(self, reference_data: pd.DataFrame):
-        """Set up reference data for drift detection"""
+        """Set up reference data for drift detection."""
         self.statistical_detector = StatisticalDriftDetector(reference_data)
         self.outlier_detector.fit(reference_data)
 
@@ -398,7 +394,7 @@ class ModelMonitor:
         predictions: np.ndarray,
         true_labels: Optional[np.ndarray] = None,
     ) -> Dict[str, Any]:
-        """Monitor a batch of data and predictions"""
+        """Monitor a batch of data and predictions."""
         monitoring_result = {
             "timestamp": datetime.now(),
             "batch_size": len(current_data),
@@ -480,11 +476,11 @@ class ModelMonitor:
         return monitoring_result
 
     def add_alert_handler(self, handler: Callable[[DriftAlert], None]):
-        """Add alert handler function"""
+        """Add alert handler function."""
         self.alert_handlers.append(handler)
 
     def get_monitoring_summary(self, days: int = 7) -> Dict[str, Any]:
-        """Get monitoring summary for the last N days"""
+        """Get monitoring summary for the last N days."""
         cutoff_date = datetime.now() - timedelta(days=days)
         recent_results = [
             result for result in self.monitoring_history if result["timestamp"] >= cutoff_date
@@ -521,7 +517,7 @@ class ModelMonitor:
         }
 
     def _analyze_predictions(self, predictions: np.ndarray) -> Dict[str, Any]:
-        """Analyze prediction distribution"""
+        """Analyze prediction distribution."""
         return {
             "mean": float(np.mean(predictions)),
             "std": float(np.std(predictions)),
@@ -533,7 +529,7 @@ class ModelMonitor:
     def _calculate_performance_metrics(
         self, predictions: np.ndarray, true_labels: np.ndarray
     ) -> ModelMetrics:
-        """Calculate model performance metrics"""
+        """Calculate model performance metrics."""
         # Convert to binary if needed
         if len(np.unique(true_labels)) == 2:
             # Binary classification
@@ -575,7 +571,7 @@ class ModelMonitor:
             )
 
     def _handle_alert(self, alert: DriftAlert):
-        """Handle drift alert"""
+        """Handle drift alert."""
         logger.warning(
             f"DRIFT ALERT: {alert.description} "
             f"(Type: {alert.drift_type.value}, Severity: {alert.severity.value})"
@@ -589,7 +585,7 @@ class ModelMonitor:
                 logger.error(f"Alert handler failed: {e}")
 
     def _save_monitoring_result(self, result: Dict[str, Any]):
-        """Save monitoring result to storage"""
+        """Save monitoring result to storage."""
         timestamp_str = result["timestamp"].strftime("%Y%m%d_%H%M%S")
         filename = self.storage_path / f"monitoring_{timestamp_str}.json"
 
@@ -606,14 +602,14 @@ class ModelMonitor:
             self.monitoring_history = self.monitoring_history[-500:]
 
     def _save_reference_profile(self, reference_data: pd.DataFrame):
-        """Save reference data profile"""
+        """Save reference data profile."""
         profile_file = self.storage_path / "reference_profile.pkl"
 
         with open(profile_file, "wb") as f:
             pickle.dump(reference_data, f)
 
     def _make_serializable(self, obj: Any) -> Any:
-        """Convert object to JSON-serializable format"""
+        """Convert object to JSON-serializable format."""
         if isinstance(obj, np.ndarray):
             return obj.tolist()
         elif isinstance(obj, np.integer):
@@ -622,7 +618,7 @@ class ModelMonitor:
             return float(obj)
         elif isinstance(obj, datetime):
             return obj.isoformat()
-        elif isinstance(obj, DriftAlert):
+        elif isinstance(obj, DriftAlert):  # noqa: SIM114
             return asdict(obj)
         elif isinstance(obj, ModelMetrics):
             return asdict(obj)
@@ -638,13 +634,13 @@ class ModelMonitor:
 
 # Example alert handlers
 def email_alert_handler(alert: DriftAlert):
-    """Example email alert handler"""
+    """Example email alert handler."""
     logger.info(f"EMAIL ALERT: {alert.description}")
     # In production, would send actual email
 
 
 def slack_alert_handler(alert: DriftAlert):
-    """Example Slack alert handler"""
+    """Example Slack alert handler."""
     logger.info(f"SLACK ALERT: {alert.description}")
     # In production, would send to Slack
 

mcli/ml/monitoring/metrics.py

@@ -1,4 +1,4 @@
-"""Prometheus metrics for monitoring"""
+"""Prometheus metrics for monitoring."""
 
 from prometheus_client import Counter, Gauge, Histogram, generate_latest
 
@@ -29,5 +29,5 @@ cache_hit_rate = Gauge("cache_hit_rate", "Cache hit rate")
 
 
 def get_metrics():
-    """Get Prometheus metrics in text format"""
+    """Get Prometheus metrics in text format."""
     return generate_latest().decode("utf-8")

mcli/ml/optimization/__init__.py

@@ -1,4 +1,4 @@
-"""Advanced Portfolio Optimization"""
+"""Advanced Portfolio Optimization."""
 
 from .portfolio_optimizer import (
     AdvancedPortfolioOptimizer,

mcli/ml/optimization/optimize.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-optimize", help="Portfolio optimization CLI for MCLI trading system")
 def cli():
     """Main CLI group for portfolio optimization."""
-    pass
 
 
 @cli.command(name="portfolio", help="Optimize portfolio allocation")