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

mcli/ml/predictions/prediction_engine.py

@@ -3,11 +3,12 @@ Prediction Engine for Politician Trading Analysis
 Generates stock predictions based on politician trading disclosures
 """
 
-import pandas as pd
-import numpy as np
+from collections import defaultdict
 from datetime import datetime, timedelta
 from typing import Dict, List, Optional, Tuple
-from collections import defaultdict
+
+import numpy as np
+import pandas as pd
 
 
 class PoliticianTradingPredictor:
@@ -33,16 +34,16 @@ class PoliticianTradingPredictor:
             return pd.DataFrame()
 
         # Ensure required columns exist
-        required_cols = ['ticker_symbol', 'transaction_type', 'amount']
-        if not all(col in disclosures.columns for col in ['ticker_symbol']):
+        required_cols = ["ticker_symbol", "transaction_type", "amount"]
+        if not all(col in disclosures.columns for col in ["ticker_symbol"]):
             return pd.DataFrame()
 
         # Filter recent trades
-        if 'disclosure_date' in disclosures.columns:
+        if "disclosure_date" in disclosures.columns:
             try:
-                disclosures['disclosure_date'] = pd.to_datetime(disclosures['disclosure_date'])
+                disclosures["disclosure_date"] = pd.to_datetime(disclosures["disclosure_date"])
                 cutoff_date = datetime.now() - timedelta(days=self.recent_days)
-                recent_disclosures = disclosures[disclosures['disclosure_date'] >= cutoff_date]
+                recent_disclosures = disclosures[disclosures["disclosure_date"] >= cutoff_date]
             except:
                 recent_disclosures = disclosures
         else:
@@ -54,20 +55,32 @@ class PoliticianTradingPredictor:
         # Analyze trading patterns by ticker
         predictions = []
 
-        for ticker in recent_disclosures['ticker_symbol'].unique():
-            if pd.isna(ticker) or ticker == '':
+        for ticker in recent_disclosures["ticker_symbol"].unique():
+            if pd.isna(ticker) or ticker == "":
                 continue
 
-            ticker_trades = recent_disclosures[recent_disclosures['ticker_symbol'] == ticker]
+            ticker_trades = recent_disclosures[recent_disclosures["ticker_symbol"] == ticker]
 
             # Calculate trading metrics
             buy_count = 0
             sell_count = 0
             total_amount = 0
 
-            if 'transaction_type' in ticker_trades.columns:
-                buy_count = len(ticker_trades[ticker_trades['transaction_type'].str.contains('purchase|buy', case=False, na=False)])
-                sell_count = len(ticker_trades[ticker_trades['transaction_type'].str.contains('sale|sell', case=False, na=False)])
+            if "transaction_type" in ticker_trades.columns:
+                buy_count = len(
+                    ticker_trades[
+                        ticker_trades["transaction_type"].str.contains(
+                            "purchase|buy", case=False, na=False
+                        )
+                    ]
+                )
+                sell_count = len(
+                    ticker_trades[
+                        ticker_trades["transaction_type"].str.contains(
+                            "sale|sell", case=False, na=False
+                        )
+                    ]
+                )
 
             total_trades = buy_count + sell_count
 
@@ -75,10 +88,10 @@ class PoliticianTradingPredictor:
                 continue
 
             # Calculate amount if available
-            if 'amount' in ticker_trades.columns:
+            if "amount" in ticker_trades.columns:
                 try:
                     # Try to extract numeric values from amount
-                    amounts = ticker_trades['amount'].astype(str)
+                    amounts = ticker_trades["amount"].astype(str)
                     # This is a simplified extraction - adjust based on actual data format
                     total_amount = len(ticker_trades) * 50000  # Rough estimate
                 except:
@@ -92,11 +105,11 @@ class PoliticianTradingPredictor:
                 sell_count=sell_count,
                 total_trades=total_trades,
                 total_amount=total_amount,
-                ticker_trades=ticker_trades
+                ticker_trades=ticker_trades,
             )
 
             if prediction:
-                prediction['ticker'] = ticker
+                prediction["ticker"] = ticker
                 predictions.append(prediction)
 
         if not predictions:
@@ -104,7 +117,7 @@ class PoliticianTradingPredictor:
 
         # Convert to DataFrame and sort by confidence
         pred_df = pd.DataFrame(predictions)
-        pred_df = pred_df.sort_values('confidence', ascending=False)
+        pred_df = pred_df.sort_values("confidence", ascending=False)
 
         return pred_df.head(50)  # Return top 50 predictions
 
@@ -114,7 +127,7 @@ class PoliticianTradingPredictor:
         sell_count: int,
         total_trades: int,
         total_amount: float,
-        ticker_trades: pd.DataFrame
+        ticker_trades: pd.DataFrame,
     ) -> Optional[Dict]:
         """
         Calculate prediction metrics for a single ticker
@@ -128,23 +141,23 @@ class PoliticianTradingPredictor:
 
         # Determine recommendation based on trading pattern
         if buy_ratio > 0.7:
-            recommendation = 'BUY'
+            recommendation = "BUY"
             predicted_return = np.random.uniform(0.02, 0.15)  # Positive return for buy signal
             risk_score = 0.3 + (np.random.random() * 0.3)  # Lower risk for strong buy
         elif sell_ratio > 0.7:
-            recommendation = 'SELL'
+            recommendation = "SELL"
             predicted_return = np.random.uniform(-0.10, -0.02)  # Negative return for sell signal
             risk_score = 0.6 + (np.random.random() * 0.3)  # Higher risk for sell
         elif buy_ratio > sell_ratio:
-            recommendation = 'BUY'
+            recommendation = "BUY"
             predicted_return = np.random.uniform(0.01, 0.08)
             risk_score = 0.4 + (np.random.random() * 0.3)
         elif sell_ratio > buy_ratio:
-            recommendation = 'SELL'
+            recommendation = "SELL"
             predicted_return = np.random.uniform(-0.05, -0.01)
             risk_score = 0.5 + (np.random.random() * 0.3)
         else:
-            recommendation = 'HOLD'
+            recommendation = "HOLD"
             predicted_return = np.random.uniform(-0.02, 0.02)
             risk_score = 0.4 + (np.random.random() * 0.4)
 
@@ -158,33 +171,29 @@ class PoliticianTradingPredictor:
 
         # Recency score
         recency_score = 0.5
-        if 'disclosure_date' in ticker_trades.columns:
+        if "disclosure_date" in ticker_trades.columns:
             try:
-                most_recent = ticker_trades['disclosure_date'].max()
+                most_recent = ticker_trades["disclosure_date"].max()
                 days_ago = (datetime.now() - most_recent).days
                 recency_score = max(0.3, 1.0 - (days_ago / self.recent_days))
             except:
                 pass
 
         # Combined confidence (weighted average)
-        confidence = (
-            trade_count_score * 0.3 +
-            consistency_score * 0.4 +
-            recency_score * 0.3
-        )
+        confidence = trade_count_score * 0.3 + consistency_score * 0.4 + recency_score * 0.3
 
         # Add some variance
         confidence = min(0.95, max(0.50, confidence + np.random.uniform(-0.05, 0.05)))
 
         return {
-            'predicted_return': predicted_return,
-            'confidence': confidence,
-            'risk_score': risk_score,
-            'recommendation': recommendation,
-            'trade_count': total_trades,
-            'buy_count': buy_count,
-            'sell_count': sell_count,
-            'signal_strength': consistency_score
+            "predicted_return": predicted_return,
+            "confidence": confidence,
+            "risk_score": risk_score,
+            "recommendation": recommendation,
+            "trade_count": total_trades,
+            "buy_count": buy_count,
+            "sell_count": sell_count,
+            "signal_strength": consistency_score,
         }
 
     def get_top_picks(self, predictions: pd.DataFrame, n: int = 10) -> pd.DataFrame:
@@ -194,30 +203,33 @@ class PoliticianTradingPredictor:
 
         # Score = confidence * abs(predicted_return)
         predictions = predictions.copy()
-        predictions['score'] = predictions['confidence'] * predictions['predicted_return'].abs()
+        predictions["score"] = predictions["confidence"] * predictions["predicted_return"].abs()
 
-        return predictions.nlargest(n, 'score')
+        return predictions.nlargest(n, "score")
 
-    def get_buy_recommendations(self, predictions: pd.DataFrame, min_confidence: float = 0.6) -> pd.DataFrame:
+    def get_buy_recommendations(
+        self, predictions: pd.DataFrame, min_confidence: float = 0.6
+    ) -> pd.DataFrame:
         """Get buy recommendations above confidence threshold"""
         if predictions.empty:
             return pd.DataFrame()
 
         buys = predictions[
-            (predictions['recommendation'] == 'BUY') &
-            (predictions['confidence'] >= min_confidence)
+            (predictions["recommendation"] == "BUY") & (predictions["confidence"] >= min_confidence)
         ]
 
-        return buys.sort_values('predicted_return', ascending=False)
+        return buys.sort_values("predicted_return", ascending=False)
 
-    def get_sell_recommendations(self, predictions: pd.DataFrame, min_confidence: float = 0.6) -> pd.DataFrame:
+    def get_sell_recommendations(
+        self, predictions: pd.DataFrame, min_confidence: float = 0.6
+    ) -> pd.DataFrame:
         """Get sell recommendations above confidence threshold"""
         if predictions.empty:
             return pd.DataFrame()
 
         sells = predictions[
-            (predictions['recommendation'] == 'SELL') &
-            (predictions['confidence'] >= min_confidence)
+            (predictions["recommendation"] == "SELL")
+            & (predictions["confidence"] >= min_confidence)
         ]
 
-        return sells.sort_values('predicted_return', ascending=True)
+        return sells.sort_values("predicted_return", ascending=True)

mcli/ml/preprocessing/data_cleaners.py

@@ -1,12 +1,13 @@
 """Data cleaning utilities for ML preprocessing"""
 
-import numpy as np
-import pandas as pd
+import logging
+import re
+from dataclasses import dataclass
 from datetime import datetime, timedelta
 from typing import Any, Dict, List, Optional, Tuple, Union
-from dataclasses import dataclass
-import re
-import logging
+
+import numpy as np
+import pandas as pd
 
 logger = logging.getLogger(__name__)
 

mcli/ml/preprocessing/feature_extractors.py

@@ -1,13 +1,14 @@
 """Feature extraction utilities for ML preprocessing"""
 
-import numpy as np
-import pandas as pd
+import logging
+import re
+from collections import Counter, defaultdict
+from dataclasses import dataclass
 from datetime import datetime, timedelta
 from typing import Any, Dict, List, Optional, Tuple, Union
-from dataclasses import dataclass
-import re
-import logging
-from collections import defaultdict, Counter
+
+import numpy as np
+import pandas as pd
 
 logger = logging.getLogger(__name__)
 

mcli/ml/preprocessing/ml_pipeline.py

@@ -3,16 +3,17 @@
 import asyncio
 import json
 import logging
+from dataclasses import asdict, dataclass
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
-from dataclasses import dataclass, asdict
 
 import pandas as pd
 
-from mcli.lib.services.data_pipeline import LSHDataPipeline, DataPipelineConfig
+from mcli.lib.services.data_pipeline import DataPipelineConfig, LSHDataPipeline
 from mcli.lib.services.lsh_client import LSHClient
 from mcli.ml.configs.mlops_manager import get_mlops_manager
+
 from .politician_trading_preprocessor import (
     PoliticianTradingPreprocessor,
     PreprocessingConfig,

mcli/ml/preprocessing/politician_trading_preprocessor.py

@@ -1,21 +1,22 @@
 """Main preprocessor for politician trading data"""
 
-import pandas as pd
-import numpy as np
-from datetime import datetime, timedelta
-from typing import Any, Dict, List, Optional, Tuple, Union
-from dataclasses import dataclass, asdict
 import logging
+from dataclasses import asdict, dataclass
+from datetime import datetime, timedelta
 from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
 import joblib
+import numpy as np
+import pandas as pd
 
-from .data_cleaners import TradingDataCleaner, OutlierDetector, MissingValueHandler, CleaningStats
+from .data_cleaners import CleaningStats, MissingValueHandler, OutlierDetector, TradingDataCleaner
 from .feature_extractors import (
-    PoliticianFeatureExtractor,
+    FeatureExtractionStats,
     MarketFeatureExtractor,
-    TemporalFeatureExtractor,
+    PoliticianFeatureExtractor,
     SentimentFeatureExtractor,
-    FeatureExtractionStats,
+    TemporalFeatureExtractor,
 )
 
 logger = logging.getLogger(__name__)
@@ -415,7 +416,7 @@ class PoliticianTradingPreprocessor:
         """Scale numerical features"""
         logger.info("Scaling features")
 
-        from sklearn.preprocessing import StandardScaler, LabelEncoder
+        from sklearn.preprocessing import LabelEncoder, StandardScaler
 
         numerical_features = self._identify_numerical_features(train_data)
         categorical_features = self._identify_categorical_features(train_data)

mcli/ml/preprocessing/test_preprocessing.py

@@ -1,13 +1,13 @@
 """Test script for the ML preprocessing pipeline"""
 
-import pandas as pd
-import numpy as np
+import logging
 from datetime import datetime, timedelta
 from pathlib import Path
-import logging
 
-from politician_trading_preprocessor import PoliticianTradingPreprocessor, PreprocessingConfig
+import numpy as np
+import pandas as pd
 from ml_pipeline import MLDataPipeline, MLDataPipelineConfig
+from politician_trading_preprocessor import PoliticianTradingPreprocessor, PreprocessingConfig
 
 # Setup logging
 logging.basicConfig(level=logging.INFO)

mcli/ml/scripts/populate_sample_data.py

@@ -1,16 +1,24 @@
 """Populate database with sample data for dashboard testing."""
 
 import asyncio
-from datetime import datetime, timedelta
 import random
+from datetime import datetime, timedelta
+
 import numpy as np
 
-from mcli.ml.database.session import SessionLocal, init_db
+from mcli.ml.config import settings
 from mcli.ml.database.models import (
-    User, Model, Prediction, Portfolio, Trade, StockData,
-    BacktestResult, ModelStatus
+    BacktestResult,
+    Model,
+    ModelStatus,
+    Portfolio,
+    Prediction,
+    StockData,
+    Trade,
+    User,
 )
-from mcli.ml.config import settings
+from mcli.ml.database.session import SessionLocal, init_db
+
 
 def populate_sample_data():
     """Populate database with sample data."""
@@ -41,7 +49,7 @@ def populate_sample_data():
                 email=f"user{i+1}@example.com",
                 role="user" if i > 0 else "admin",
                 is_active=True,
-                last_login_at=datetime.utcnow() - timedelta(hours=random.randint(1, 48))
+                last_login_at=datetime.utcnow() - timedelta(hours=random.randint(1, 48)),
             )
             users.append(user)
             db.add(user)
@@ -51,7 +59,13 @@ def populate_sample_data():
         # Create sample models
         print("Creating sample models...")
         models = []
-        model_names = ["LSTM Predictor", "Transformer Model", "Ensemble Model", "CNN Extractor", "Attention Model"]
+        model_names = [
+            "LSTM Predictor",
+            "Transformer Model",
+            "Ensemble Model",
+            "CNN Extractor",
+            "Attention Model",
+        ]
         for i, name in enumerate(model_names):
             model = Model(
                 name=name,
@@ -63,7 +77,7 @@ def populate_sample_data():
                 test_max_drawdown=random.uniform(0.05, 0.15),
                 created_at=datetime.utcnow() - timedelta(days=random.randint(1, 30)),
                 updated_at=datetime.utcnow() - timedelta(hours=random.randint(1, 24)),
-                created_by_id=random.choice(users).id
+                created_by_id=random.choice(users).id,
             )
             models.append(model)
             db.add(model)
@@ -73,7 +87,13 @@ def populate_sample_data():
         # Create sample portfolios
         print("Creating sample portfolios...")
         portfolios = []
-        portfolio_names = ["Growth Portfolio", "Value Portfolio", "AI Picks", "Risk Parity", "Momentum Strategy"]
+        portfolio_names = [
+            "Growth Portfolio",
+            "Value Portfolio",
+            "AI Picks",
+            "Risk Parity",
+            "Momentum Strategy",
+        ]
         for i, name in enumerate(portfolio_names):
             portfolio = Portfolio(
                 name=name,
@@ -84,7 +104,7 @@ def populate_sample_data():
                 sharpe_ratio=random.uniform(0.8, 2.0),
                 max_drawdown=random.uniform(0.05, 0.20),
                 is_active=i < 4,
-                created_by_id=random.choice(users).id
+                created_by_id=random.choice(users).id,
             )
             portfolios.append(portfolio)
             db.add(portfolio)
@@ -102,7 +122,7 @@ def populate_sample_data():
                 target_date=datetime.utcnow().date() + timedelta(days=random.randint(1, 30)),
                 predicted_return=random.uniform(-0.05, 0.05),
                 confidence_score=random.uniform(0.5, 0.95),
-                model_id=random.choice(models).id
+                model_id=random.choice(models).id,
             )
             db.add(prediction)
 
@@ -114,7 +134,7 @@ def populate_sample_data():
                 target_date=datetime.utcnow().date() + timedelta(days=7),
                 predicted_return=random.uniform(-0.03, 0.03),
                 confidence_score=random.uniform(0.6, 0.9),
-                model_id=random.choice(models).id
+                model_id=random.choice(models).id,
             )
             db.add(prediction)
 
@@ -134,7 +154,7 @@ def populate_sample_data():
                     low=base_price * random.uniform(0.97, 0.99),
                     close=base_price * random.uniform(0.98, 1.02),
                     volume=random.randint(1000000, 50000000),
-                    adjusted_close=base_price * random.uniform(0.98, 1.02)
+                    adjusted_close=base_price * random.uniform(0.98, 1.02),
                 )
                 db.add(stock_data)
                 base_price = stock_data.close  # Random walk
@@ -152,7 +172,7 @@ def populate_sample_data():
                         trade_type=random.choice(["buy", "sell"]),
                         quantity=random.randint(10, 100),
                         price=random.uniform(50, 500),
-                        executed_at=datetime.utcnow() - timedelta(days=random.randint(0, 30))
+                        executed_at=datetime.utcnow() - timedelta(days=random.randint(0, 30)),
                     )
                     db.add(trade)
 
@@ -173,7 +193,7 @@ def populate_sample_data():
                     max_drawdown=random.uniform(0.05, 0.25),
                     win_rate=random.uniform(0.45, 0.65),
                     profit_factor=random.uniform(0.9, 2.0),
-                    total_trades=random.randint(50, 200)
+                    total_trades=random.randint(50, 200),
                 )
                 db.add(backtest)
 
@@ -197,4 +217,4 @@ def populate_sample_data():
 
 
 if __name__ == "__main__":
-    populate_sample_data()
+    populate_sample_data()