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

mcli/ml/features/recommendation_engine.py

@@ -1,10 +1,10 @@
-"""Stock recommendation engine that combines all feature engineering components"""
+"""Stock recommendation engine that combines all feature engineering components."""
 
 import logging
-from dataclasses import asdict, dataclass
-from datetime import datetime, timedelta
+from dataclasses import dataclass
+from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Tuple
 
 import joblib
 import numpy as np
@@ -31,7 +31,7 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class RecommendationConfig:
-    """Configuration for stock recommendation engine"""
+    """Configuration for stock recommendation engine."""
 
     # Feature engineering components
     enable_technical_features: bool = True
@@ -73,7 +73,7 @@ class RecommendationConfig:
 
 @dataclass
 class RecommendationResult:
-    """Result from stock recommendation engine"""
+    """Result from stock recommendation engine."""
 
     # Basic information
     ticker: str
@@ -105,7 +105,7 @@ class RecommendationResult:
 
 
 class StockRecommendationEngine:
-    """Comprehensive stock recommendation engine"""
+    """Comprehensive stock recommendation engine."""
 
     def __init__(self, config: Optional[RecommendationConfig] = None):
         self.config = config or RecommendationConfig()
@@ -132,7 +132,7 @@ class StockRecommendationEngine:
         politician_metadata: Optional[pd.DataFrame] = None,
         market_data: Optional[Dict[str, pd.DataFrame]] = None,
     ) -> List[RecommendationResult]:
-        """Generate stock recommendations based on politician trading data"""
+        """Generate stock recommendations based on politician trading data."""
 
         logger.info("Starting stock recommendation generation")
 
@@ -170,7 +170,7 @@ class StockRecommendationEngine:
         politician_metadata: Optional[pd.DataFrame],
         market_data: Optional[Dict[str, pd.DataFrame]],
     ) -> pd.DataFrame:
-        """Extract all features for recommendation generation"""
+        """Extract all features for recommendation generation."""
 
         logger.info("Extracting comprehensive feature set")
         df = trading_data.copy()
@@ -204,7 +204,7 @@ class StockRecommendationEngine:
     def _add_technical_features(
         self, df: pd.DataFrame, stock_price_data: pd.DataFrame
     ) -> pd.DataFrame:
-        """Add technical analysis features"""
+        """Add technical analysis features."""
         logger.info("Adding technical features")
 
         # Merge stock price data
@@ -254,7 +254,7 @@ class StockRecommendationEngine:
     def _add_political_features(
         self, df: pd.DataFrame, politician_metadata: Optional[pd.DataFrame]
     ) -> pd.DataFrame:
-        """Add political influence features"""
+        """Add political influence features."""
         logger.info("Adding political features")
 
         # Political influence features
@@ -275,7 +275,7 @@ class StockRecommendationEngine:
         stock_price_data: pd.DataFrame,
         market_data: Optional[Dict[str, pd.DataFrame]],
     ) -> pd.DataFrame:
-        """Add market regime features"""
+        """Add market regime features."""
         logger.info("Adding market regime features")
 
         # Add market regime features from stock price data
@@ -294,7 +294,7 @@ class StockRecommendationEngine:
         return df
 
     def _add_ensemble_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Add ensemble features"""
+        """Add ensemble features."""
         logger.info("Adding ensemble features")
 
         # Build ensemble features
@@ -309,7 +309,7 @@ class StockRecommendationEngine:
         return df
 
     def _add_interaction_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Add feature interactions"""
+        """Add feature interactions."""
         logger.info("Adding interaction features")
 
         # Get important feature pairs (mock implementation)
@@ -333,7 +333,7 @@ class StockRecommendationEngine:
         return df
 
     def _perform_feature_selection(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Perform feature selection"""
+        """Perform feature selection."""
         logger.info("Performing feature selection")
 
         # Create a synthetic target for feature selection if none exists
@@ -387,7 +387,7 @@ class StockRecommendationEngine:
     def _generate_stock_recommendation(
         self, stock_data: pd.DataFrame, ticker: str
     ) -> Optional[RecommendationResult]:
-        """Generate recommendation for a specific stock"""
+        """Generate recommendation for a specific stock."""
 
         try:
             # Calculate component scores
@@ -460,7 +460,7 @@ class StockRecommendationEngine:
             return None
 
     def _calculate_technical_score(self, stock_data: pd.DataFrame) -> float:
-        """Calculate technical analysis score"""
+        """Calculate technical analysis score."""
         try:
             technical_indicators = []
 
@@ -497,7 +497,7 @@ class StockRecommendationEngine:
             return 0.5
 
     def _calculate_political_score(self, stock_data: pd.DataFrame) -> float:
-        """Calculate political influence score"""
+        """Calculate political influence score."""
         try:
             political_factors = []
 
@@ -528,7 +528,7 @@ class StockRecommendationEngine:
             return 0.5
 
     def _calculate_regime_score(self, stock_data: pd.DataFrame) -> float:
-        """Calculate market regime score"""
+        """Calculate market regime score."""
         try:
             regime_factors = []
 
@@ -571,7 +571,7 @@ class StockRecommendationEngine:
             return 0.5
 
     def _calculate_ensemble_score(self, stock_data: pd.DataFrame) -> float:
-        """Calculate ensemble model score"""
+        """Calculate ensemble model score."""
         try:
             # Use cluster-based scoring as proxy for ensemble
             ensemble_factors = []
@@ -596,7 +596,7 @@ class StockRecommendationEngine:
             return 0.5
 
     def _assess_risk_level(self, stock_data: pd.DataFrame) -> str:
-        """Assess risk level for the stock"""
+        """Assess risk level for the stock."""
         try:
             risk_factors = []
 
@@ -629,11 +629,11 @@ class StockRecommendationEngine:
             return "medium"
 
     def _risk_to_numeric(self, risk_level: str) -> float:
-        """Convert risk level to numeric value"""
+        """Convert risk level to numeric value."""
         return {"low": 0.2, "medium": 0.5, "high": 0.8}.get(risk_level, 0.5)
 
     def _calculate_confidence(self, stock_data: pd.DataFrame, final_score: float) -> float:
-        """Calculate confidence in the recommendation"""
+        """Calculate confidence in the recommendation."""
         try:
             confidence_factors = []
 
@@ -658,7 +658,7 @@ class StockRecommendationEngine:
     def _generate_outlooks(
         self, stock_data: pd.DataFrame, final_score: float
     ) -> Tuple[str, str, str]:
-        """Generate short, medium, and long-term outlooks"""
+        """Generate short, medium, and long-term outlooks."""
 
         def score_to_outlook(score):
             if score >= 0.7:
@@ -676,7 +676,7 @@ class StockRecommendationEngine:
         return short_term, medium_term, long_term
 
     def _get_key_features(self, stock_data: pd.DataFrame) -> Tuple[List[str], Dict[str, float]]:
-        """Get key features and their importance"""
+        """Get key features and their importance."""
         try:
             # Get numerical features
             numerical_features = [
@@ -695,7 +695,7 @@ class StockRecommendationEngine:
                     variance = stock_data[feature].var()
                     importance = value * (1 + variance)
                     feature_importance[feature] = importance
-                except:
+                except Exception:
                     feature_importance[feature] = 0
 
             # Sort by importance
@@ -715,7 +715,7 @@ class StockRecommendationEngine:
     def _generate_explanation(
         self, stock_data: pd.DataFrame, final_score: float, key_features: List[str]
     ) -> str:
-        """Generate human-readable explanation for the recommendation"""
+        """Generate human-readable explanation for the recommendation."""
 
         try:
             if final_score >= 0.7:
@@ -746,7 +746,7 @@ class StockRecommendationEngine:
             return "Recommendation based on comprehensive analysis."
 
     def _generate_warnings(self, stock_data: pd.DataFrame, final_score: float) -> List[str]:
-        """Generate warnings for the recommendation"""
+        """Generate warnings for the recommendation."""
 
         warnings = []
 
@@ -777,7 +777,7 @@ class StockRecommendationEngine:
         return warnings
 
     def save_model_artifacts(self, artifacts_dir: Path):
-        """Save model artifacts and configurations"""
+        """Save model artifacts and configurations."""
         artifacts_dir.mkdir(parents=True, exist_ok=True)
 
         # Save configuration
@@ -792,7 +792,7 @@ class StockRecommendationEngine:
         logger.info(f"Saved model artifacts to {artifacts_dir}")
 
     def load_model_artifacts(self, artifacts_dir: Path):
-        """Load model artifacts and configurations"""
+        """Load model artifacts and configurations."""
         try:
             # Load configuration
             config_path = artifacts_dir / "recommendation_config.joblib"

mcli/ml/features/stock_features.py

@@ -1,11 +1,8 @@
-"""Stock-specific feature engineering for recommendation models"""
+"""Stock-specific feature engineering for recommendation models."""
 
 import logging
-import warnings
-from collections import defaultdict
 from dataclasses import dataclass
-from datetime import datetime, timedelta
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Tuple
 
 import numpy as np
 import pandas as pd
@@ -15,7 +12,7 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class StockFeatureConfig:
-    """Configuration for stock feature extraction"""
+    """Configuration for stock feature extraction."""
 
     # Technical indicator periods
     sma_periods: List[int] = None
@@ -50,13 +47,13 @@ class StockFeatureConfig:
 
 
 class StockRecommendationFeatures:
-    """Core stock recommendation feature extractor"""
+    """Core stock recommendation feature extractor."""
 
     def __init__(self, config: Optional[StockFeatureConfig] = None):
         self.config = config or StockFeatureConfig()
 
     def extract_features(self, stock_data: pd.DataFrame) -> pd.DataFrame:
-        """Extract stock recommendation features"""
+        """Extract stock recommendation features."""
         logger.info("Extracting stock recommendation features")
 
         df = stock_data.copy()
@@ -89,7 +86,7 @@ class StockRecommendationFeatures:
         return df
 
     def _extract_price_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract price-based features"""
+        """Extract price-based features."""
         # Basic price relationships
         df["hl_ratio"] = (df["high"] - df["low"]) / df["close"]
         df["oc_ratio"] = (df["open"] - df["close"]) / df["close"]
@@ -125,7 +122,7 @@ class StockRecommendationFeatures:
         return df
 
     def _extract_volume_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract volume-based features"""
+        """Extract volume-based features."""
         # Volume moving averages
         for period in self.config.volume_ma_periods:
             df[f"volume_ma_{period}"] = df["volume"].rolling(window=period).mean()
@@ -158,7 +155,7 @@ class StockRecommendationFeatures:
         return df
 
     def _extract_volatility_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract volatility-based features"""
+        """Extract volatility-based features."""
         # Calculate returns
         df["returns"] = df["close"].pct_change()
         df["log_returns"] = np.log(df["close"] / df["close"].shift(1))
@@ -197,7 +194,7 @@ class StockRecommendationFeatures:
         return df
 
     def _extract_momentum_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract momentum-based features"""
+        """Extract momentum-based features."""
         # RSI (Relative Strength Index)
         delta = df["close"].diff()
         gain = delta.where(delta > 0, 0).rolling(window=self.config.rsi_period).mean()
@@ -234,7 +231,7 @@ class StockRecommendationFeatures:
         return df
 
     def _extract_trend_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract trend-based features"""
+        """Extract trend-based features."""
         # Trend strength
         for window in [10, 20, 50]:
             # Linear regression slope
@@ -255,7 +252,7 @@ class StockRecommendationFeatures:
                     ss_res = np.sum((prices - predicted) ** 2)
                     ss_tot = np.sum((prices - np.mean(prices)) ** 2)
                     return 1 - (ss_res / ss_tot) if ss_tot != 0 else 0
-                except:
+                except Exception:
                     return 0
 
             df[f"trend_strength_{window}"] = (
@@ -283,13 +280,13 @@ class StockRecommendationFeatures:
 
 
 class TechnicalIndicatorFeatures:
-    """Advanced technical indicator features"""
+    """Advanced technical indicator features."""
 
     def __init__(self, config: Optional[StockFeatureConfig] = None):
         self.config = config or StockFeatureConfig()
 
     def extract_advanced_indicators(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract advanced technical indicators"""
+        """Extract advanced technical indicators."""
         df = df.copy()
 
         # Williams %R
@@ -315,13 +312,13 @@ class TechnicalIndicatorFeatures:
         return df
 
     def _williams_r(self, df: pd.DataFrame, period: int = 14) -> pd.Series:
-        """Williams %R oscillator"""
+        """Williams %R oscillator."""
         highest_high = df["high"].rolling(window=period).max()
         lowest_low = df["low"].rolling(window=period).min()
         return -100 * (highest_high - df["close"]) / (highest_high - lowest_low)
 
     def _commodity_channel_index(self, df: pd.DataFrame, period: int = 20) -> pd.Series:
-        """Commodity Channel Index"""
+        """Commodity Channel Index."""
         typical_price = (df["high"] + df["low"] + df["close"]) / 3
         sma_tp = typical_price.rolling(window=period).mean()
         mad = typical_price.rolling(window=period).apply(
@@ -330,7 +327,7 @@ class TechnicalIndicatorFeatures:
         return (typical_price - sma_tp) / (0.015 * mad)
 
     def _money_flow_index(self, df: pd.DataFrame, period: int = 14) -> pd.Series:
-        """Money Flow Index"""
+        """Money Flow Index."""
         typical_price = (df["high"] + df["low"] + df["close"]) / 3
         money_flow = typical_price * df["volume"]
 
@@ -344,7 +341,7 @@ class TechnicalIndicatorFeatures:
         return mfi
 
     def _aroon_indicator(self, df: pd.DataFrame, period: int = 25) -> Tuple[pd.Series, pd.Series]:
-        """Aroon Up and Aroon Down indicators"""
+        """Aroon Up and Aroon Down indicators."""
         aroon_up = (
             100 * (period - df["high"].rolling(window=period).apply(np.argmax, raw=False)) / period
         )
@@ -354,9 +351,9 @@ class TechnicalIndicatorFeatures:
         return aroon_up, aroon_down
 
     def _parabolic_sar(self, df: pd.DataFrame) -> pd.Series:
-        """Parabolic SAR indicator (simplified version)"""
+        """Parabolic SAR indicator (simplified version)."""
         # Simplified PSAR implementation
-        high = df["high"].values
+        df["high"].values
         low = df["low"].values
         close = df["close"].values
 
@@ -371,7 +368,7 @@ class TechnicalIndicatorFeatures:
         return pd.Series(psar, index=df.index)
 
     def _ichimoku_cloud(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Ichimoku Cloud components"""
+        """Ichimoku Cloud components."""
         # Tenkan-sen (Conversion Line)
         tenkan_high = df["high"].rolling(window=9).max()
         tenkan_low = df["low"].rolling(window=9).min()
@@ -408,13 +405,13 @@ class TechnicalIndicatorFeatures:
 
 
 class MarketRegimeFeatures:
-    """Market regime detection features"""
+    """Market regime detection features."""
 
     def __init__(self, config: Optional[StockFeatureConfig] = None):
         self.config = config or StockFeatureConfig()
 
     def extract_regime_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract market regime features"""
+        """Extract market regime features."""
         df = df.copy()
 
         # Volatility regime
@@ -432,7 +429,7 @@ class MarketRegimeFeatures:
         return df
 
     def _volatility_regime(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Identify volatility regimes"""
+        """Identify volatility regimes."""
         returns = df["close"].pct_change()
         vol_20 = returns.rolling(window=20).std() * np.sqrt(252)
 
@@ -451,7 +448,7 @@ class MarketRegimeFeatures:
         return df
 
     def _trend_regime(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Identify trend regimes"""
+        """Identify trend regimes."""
         # Multiple timeframe trend analysis
         for window in [20, 50, 200]:
             sma = df["close"].rolling(window=window).mean()
@@ -475,7 +472,7 @@ class MarketRegimeFeatures:
         return df
 
     def _volume_regime(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Identify volume regimes"""
+        """Identify volume regimes."""
         volume_ma = df["volume"].rolling(window=20).mean()
         volume_ratio = df["volume"] / volume_ma
 
@@ -497,7 +494,7 @@ class MarketRegimeFeatures:
         return df
 
     def _market_stress_indicators(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Market stress and fear indicators"""
+        """Market stress and fear indicators."""
         returns = df["close"].pct_change()
 
         # Maximum drawdown
@@ -524,7 +521,7 @@ class MarketRegimeFeatures:
 
 
 class CrossAssetFeatures:
-    """Cross-asset and correlation features"""
+    """Cross-asset and correlation features."""
 
     def __init__(self):
         pass
@@ -532,7 +529,7 @@ class CrossAssetFeatures:
     def extract_cross_asset_features(
         self, primary_df: pd.DataFrame, market_data: Dict[str, pd.DataFrame]
     ) -> pd.DataFrame:
-        """Extract features based on relationships with other assets"""
+        """Extract features based on relationships with other assets."""
         df = primary_df.copy()
 
         # Correlation with market indices
@@ -554,7 +551,7 @@ class CrossAssetFeatures:
                         covariance = np.cov(stock_ret, market_ret)[0][1]
                         market_variance = np.var(market_ret)
                         return covariance / market_variance if market_variance != 0 else 1.0
-                    except:
+                    except Exception:
                         return 1.0
 
                 rolling_beta = pd.Series(index=df.index, dtype=float)

mcli/ml/features/test_feature_engineering.py

@@ -1,4 +1,4 @@
-"""Test script for feature engineering system"""
+"""Test script for feature engineering system."""
 
 import os
 import sys
@@ -17,7 +17,7 @@ logger = logging.getLogger(__name__)
 
 
 def generate_mock_trading_data(n_records: int = 100) -> pd.DataFrame:
-    """Generate mock politician trading data"""
+    """Generate mock politician trading data."""
     np.random.seed(42)
 
     politicians = ["Nancy Pelosi", "Mitch McConnell", "Chuck Schumer", "Kevin McCarthy"]
@@ -36,7 +36,7 @@ def generate_mock_trading_data(n_records: int = 100) -> pd.DataFrame:
     records = []
     start_date = datetime.now() - timedelta(days=365)
 
-    for i in range(n_records):
+    for _i in range(n_records):
         days_ago = np.random.randint(0, 365)
         trade_date = start_date + timedelta(days=days_ago)
 
@@ -60,7 +60,7 @@ def generate_mock_trading_data(n_records: int = 100) -> pd.DataFrame:
 
 
 def generate_mock_stock_data(tickers: list, days: int = 365) -> pd.DataFrame:
-    """Generate mock stock price data"""
+    """Generate mock stock price data."""
     np.random.seed(42)
 
     stock_data = []
@@ -99,7 +99,7 @@ def generate_mock_stock_data(tickers: list, days: int = 365) -> pd.DataFrame:
 
 
 def test_stock_features():
-    """Test stock feature extraction"""
+    """Test stock feature extraction."""
     logger.info("Testing stock features...")
 
     from stock_features import StockRecommendationFeatures, TechnicalIndicatorFeatures
@@ -135,7 +135,7 @@ def test_stock_features():
 
 
 def test_political_features():
-    """Test political feature extraction"""
+    """Test political feature extraction."""
     logger.info("Testing political features...")
 
     from political_features import PoliticalInfluenceFeatures
@@ -171,7 +171,7 @@ def test_political_features():
 
 
 def test_ensemble_features():
-    """Test ensemble feature engineering"""
+    """Test ensemble feature engineering."""
     logger.info("Testing ensemble features...")
 
     from ensemble_features import EnsembleFeatureBuilder
@@ -207,7 +207,7 @@ def test_ensemble_features():
 
 
 def test_recommendation_engine():
-    """Test the full recommendation engine"""
+    """Test the full recommendation engine."""
     logger.info("Testing recommendation engine...")
 
     from recommendation_engine import RecommendationConfig, StockRecommendationEngine
@@ -257,12 +257,11 @@ def test_recommendation_engine():
 
 
 def test_feature_integration():
-    """Test integration of all feature components"""
+    """Test integration of all feature components."""
     logger.info("Testing feature integration...")
 
     from ensemble_features import EnsembleFeatureBuilder
     from political_features import PoliticalInfluenceFeatures
-    from stock_features import StockRecommendationFeatures
 
     # Generate test data
     trading_data = generate_mock_trading_data(30)
@@ -304,7 +303,7 @@ def test_feature_integration():
 
 
 def main():
-    """Run all feature engineering tests"""
+    """Run all feature engineering tests."""
     logger.info("Starting feature engineering tests...")
 
     try:

mcli/ml/logging.py

@@ -1,4 +1,4 @@
-"""Logging configuration for ML system"""
+"""Logging configuration for ML system."""
 
 import json
 import logging
@@ -11,7 +11,7 @@ from mcli.ml.config import settings
 
 
 class StructuredFormatter(logging.Formatter):
-    """JSON structured logging formatter"""
+    """JSON structured logging formatter."""
 
     def format(self, record):
         log_obj = {
@@ -34,7 +34,7 @@ class StructuredFormatter(logging.Formatter):
 
 
 def setup_logging():
-    """Configure logging for the application"""
+    """Configure logging for the application."""
 
     # Create logs directory
     log_dir = Path("logs")
@@ -76,5 +76,5 @@ def setup_logging():
 
 
 def get_logger(name: str) -> logging.Logger:
-    """Get a logger instance"""
+    """Get a logger instance."""
     return logging.getLogger(name)

mcli/ml/mlops/__init__.py

@@ -1,4 +1,4 @@
-"""MLOps components for ML pipeline management"""
+"""MLOps components for ML pipeline management."""
 
 from .experiment_tracker import ExperimentRun, ExperimentTracker, MLflowConfig, ModelRegistry
 from .model_serving import ModelEndpoint, ModelServer, PredictionService