mcli-framework 7.12.1__py3-none-any.whl → 7.12.3__py3-none-any.whl

mcli/ml/mlops/model_serving.py

@@ -1,21 +1,18 @@
-"""REST API for model serving"""
+"""REST API for model serving."""
 
-import asyncio
 import json
 import logging
 import os
 import sys
 from contextlib import asynccontextmanager
 from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 
 import numpy as np
 import pandas as pd
 import torch
 import uvicorn
 from fastapi import BackgroundTasks, FastAPI, File, HTTPException, UploadFile
-from fastapi.responses import JSONResponse
 from pydantic import BaseModel, Field
 
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../.."))
@@ -30,7 +27,7 @@ logger = logging.getLogger(__name__)
 
 # Pydantic models for API
 class PredictionRequest(BaseModel):
-    """Request model for predictions"""
+    """Request model for predictions."""
 
     trading_data: Dict[str, Any] = Field(..., description="Politician trading data")
     stock_data: Optional[Dict[str, Any]] = Field(None, description="Stock price data")
@@ -39,7 +36,7 @@ class PredictionRequest(BaseModel):
 
 
 class PredictionResponse(BaseModel):
-    """Response model for predictions"""
+    """Response model for predictions."""
 
     recommendations: List[Dict[str, Any]]
     timestamp: str
@@ -48,7 +45,7 @@ class PredictionResponse(BaseModel):
 
 
 class HealthResponse(BaseModel):
-    """Health check response"""
+    """Health check response."""
 
     status: str
     model_loaded: bool
@@ -57,7 +54,7 @@ class HealthResponse(BaseModel):
 
 
 class ModelMetricsResponse(BaseModel):
-    """Model metrics response"""
+    """Model metrics response."""
 
     accuracy: float
     precision: float
@@ -67,14 +64,14 @@ class ModelMetricsResponse(BaseModel):
 
 
 class BatchPredictionRequest(BaseModel):
-    """Batch prediction request"""
+    """Batch prediction request."""
 
     batch_id: str
     data: List[PredictionRequest]
 
 
 class BatchPredictionResponse(BaseModel):
-    """Batch prediction response"""
+    """Batch prediction response."""
 
     batch_id: str
     status: str
@@ -83,7 +80,7 @@ class BatchPredictionResponse(BaseModel):
 
 
 class ModelEndpoint:
-    """Model endpoint manager"""
+    """Model endpoint manager."""
 
     def __init__(self, model_path: Optional[str] = None):
         self.model = None
@@ -100,7 +97,7 @@ class ModelEndpoint:
         self._setup_feature_extractors()
 
     def _setup_feature_extractors(self):
-        """Initialize feature extractors"""
+        """Initialize feature extractors."""
         self.feature_extractors = {
             "stock": StockRecommendationFeatures(),
             "political": PoliticalInfluenceFeatures(),
@@ -109,7 +106,7 @@ class ModelEndpoint:
         logger.info("Feature extractors initialized")
 
     def load_model(self, model_path: str):
-        """Load model from file"""
+        """Load model from file."""
         try:
             checkpoint = torch.load(model_path, map_location="cpu")
 
@@ -151,7 +148,7 @@ class ModelEndpoint:
     def extract_features(
         self, trading_data: pd.DataFrame, stock_data: Optional[pd.DataFrame] = None
     ) -> np.ndarray:
-        """Extract features from raw data"""
+        """Extract features from raw data."""
         features = pd.DataFrame()
 
         # Extract political features
@@ -176,7 +173,7 @@ class ModelEndpoint:
         return features.values if not features.empty else np.array([[]])
 
     async def predict(self, request: PredictionRequest) -> PredictionResponse:
-        """Generate predictions"""
+        """Generate predictions."""
         start_time = datetime.now()
 
         try:
@@ -259,7 +256,7 @@ class ModelEndpoint:
             raise HTTPException(status_code=500, detail=str(e))
 
     def _generate_mock_recommendations(self, tickers: List[str]) -> List[PortfolioRecommendation]:
-        """Generate mock recommendations for testing"""
+        """Generate mock recommendations for testing."""
         recommendations = []
         for ticker in tickers:
             rec = PortfolioRecommendation(
@@ -276,7 +273,7 @@ class ModelEndpoint:
         return recommendations
 
     def get_health(self) -> HealthResponse:
-        """Get endpoint health status"""
+        """Get endpoint health status."""
         uptime = (datetime.now() - self.start_time).total_seconds()
 
         return HealthResponse(
@@ -287,7 +284,7 @@ class ModelEndpoint:
         )
 
     def get_metrics(self) -> Dict[str, Any]:
-        """Get endpoint metrics"""
+        """Get endpoint metrics."""
         return {
             **self.metrics,
             "model_version": self.model_version,
@@ -297,7 +294,7 @@ class ModelEndpoint:
 
 
 class PredictionService:
-    """Async prediction service for batch processing"""
+    """Async prediction service for batch processing."""
 
     def __init__(self, model_endpoint: ModelEndpoint):
         self.model_endpoint = model_endpoint
@@ -305,7 +302,7 @@ class PredictionService:
         self.executor = None
 
     async def process_batch(self, batch_request: BatchPredictionRequest) -> BatchPredictionResponse:
-        """Process batch predictions asynchronously"""
+        """Process batch predictions asynchronously."""
         batch_id = batch_request.batch_id
 
         # Initialize batch job
@@ -341,7 +338,7 @@ class PredictionService:
         )
 
     def get_batch_status(self, batch_id: str) -> BatchPredictionResponse:
-        """Get batch job status"""
+        """Get batch job status."""
         if batch_id not in self.batch_jobs:
             raise HTTPException(status_code=404, detail="Batch job not found")
 
@@ -356,7 +353,7 @@ class PredictionService:
 
 
 class ModelServer:
-    """FastAPI model server"""
+    """FastAPI model server."""
 
     def __init__(self, model_path: Optional[str] = None):
         self.model_endpoint = ModelEndpoint(model_path)
@@ -365,7 +362,7 @@ class ModelServer:
 
     @asynccontextmanager
     async def lifespan(self, app: FastAPI):
-        """Manage application lifecycle"""
+        """Manage application lifecycle."""
         # Startup
         logger.info("Starting model server...")
         yield
@@ -373,7 +370,7 @@ class ModelServer:
         logger.info("Shutting down model server...")
 
     def _create_app(self) -> FastAPI:
-        """Create FastAPI application"""
+        """Create FastAPI application."""
         app = FastAPI(
             title="Stock Recommendation API",
             description="ML-powered stock recommendation system based on politician trading data",
@@ -384,19 +381,19 @@ class ModelServer:
         # Health check
         @app.get("/health", response_model=HealthResponse)
         async def health():
-            """Health check endpoint"""
+            """Health check endpoint."""
             return self.model_endpoint.get_health()
 
         # Metrics
         @app.get("/metrics")
         async def metrics():
-            """Get service metrics"""
+            """Get service metrics."""
             return self.model_endpoint.get_metrics()
 
         # Single prediction
         @app.post("/predict", response_model=PredictionResponse)
         async def predict(request: PredictionRequest):
-            """Generate stock recommendations"""
+            """Generate stock recommendations."""
             return await self.model_endpoint.predict(request)
 
         # Batch prediction
@@ -404,7 +401,7 @@ class ModelServer:
         async def batch_predict(
             batch_request: BatchPredictionRequest, background_tasks: BackgroundTasks
         ):
-            """Submit batch prediction job"""
+            """Submit batch prediction job."""
             background_tasks.add_task(self.prediction_service.process_batch, batch_request)
 
             return BatchPredictionResponse(
@@ -414,13 +411,13 @@ class ModelServer:
         # Batch status
         @app.get("/batch/{batch_id}", response_model=BatchPredictionResponse)
         async def batch_status(batch_id: str):
-            """Get batch job status"""
+            """Get batch job status."""
             return self.prediction_service.get_batch_status(batch_id)
 
         # Model reload
         @app.post("/model/reload")
         async def reload_model(model_path: str):
-            """Reload model from new path"""
+            """Reload model from new path."""
             try:
                 self.model_endpoint.load_model(model_path)
                 return {"status": "success", "model_version": self.model_endpoint.model_version}
@@ -430,7 +427,7 @@ class ModelServer:
         # Upload and predict
         @app.post("/upload/predict")
         async def upload_predict(file: UploadFile = File(...)):
-            """Upload CSV and get predictions"""
+            """Upload CSV and get predictions."""
             try:
                 # Read uploaded file
                 content = await file.read()
@@ -455,12 +452,12 @@ class ModelServer:
         return app
 
     def run(self, host: str = "0.0.0.0", port: int = 8000):
-        """Run the server"""
+        """Run the server."""
         uvicorn.run(self.app, host=host, port=port)
 
 
 def main():
-    """Run the model server"""
+    """Run the model server."""
     import argparse
 
     parser = argparse.ArgumentParser(description="Stock Recommendation Model Server")

mcli/ml/mlops/pipeline_orchestrator.py

@@ -1,33 +1,25 @@
-"""End-to-end ML pipeline orchestrator"""
+"""End-to-end ML pipeline orchestrator."""
 
 import os
 import sys
 
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../.."))
 
-import json
 import logging
 import pickle
 from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional
 
 import numpy as np
 import pandas as pd
 import torch
 from ml.features.ensemble_features import EnsembleFeatureBuilder
 from ml.features.political_features import PoliticalInfluenceFeatures
-from ml.features.recommendation_engine import RecommendationConfig as FeatureRecommendationConfig
-from ml.features.recommendation_engine import StockRecommendationEngine
 from ml.features.stock_features import StockRecommendationFeatures
-from ml.models.ensemble_models import (
-    DeepEnsembleModel,
-    EnsembleConfig,
-    EnsembleTrainer,
-    ModelConfig,
-)
+from ml.models.ensemble_models import EnsembleConfig, ModelConfig
 from ml.models.recommendation_models import (
     RecommendationConfig,
     RecommendationTrainer,
@@ -41,7 +33,7 @@ logger = logging.getLogger(__name__)
 
 
 class PipelineStage(Enum):
-    """Pipeline execution stages"""
+    """Pipeline execution stages."""
 
     DATA_INGESTION = "data_ingestion"
     DATA_PREPROCESSING = "data_preprocessing"
@@ -53,7 +45,7 @@ class PipelineStage(Enum):
 
 @dataclass
 class PipelineStep:
-    """Individual pipeline step configuration"""
+    """Individual pipeline step configuration."""
 
     name: str
     stage: PipelineStage
@@ -68,7 +60,7 @@ class PipelineStep:
 
 @dataclass
 class PipelineConfig:
-    """Complete pipeline configuration"""
+    """Complete pipeline configuration."""
 
     name: str = "politician-trading-ml-pipeline"
     version: str = "1.0.0"
@@ -93,7 +85,7 @@ class PipelineConfig:
 
 
 class MLPipeline:
-    """End-to-end ML pipeline orchestrator"""
+    """End-to-end ML pipeline orchestrator."""
 
     def __init__(self, config: PipelineConfig):
         self.config = config
@@ -115,7 +107,7 @@ class MLPipeline:
         self._setup_default_pipeline()
 
     def _setup_default_pipeline(self):
-        """Setup default pipeline steps"""
+        """Setup default pipeline steps."""
         # Data ingestion
         self.add_step(
             PipelineStep(
@@ -189,12 +181,12 @@ class MLPipeline:
         )
 
     def add_step(self, step: PipelineStep):
-        """Add step to pipeline"""
+        """Add step to pipeline."""
         self.steps.append(step)
         logger.debug(f"Added pipeline step: {step.name}")
 
     def _load_raw_data(self) -> Dict[str, pd.DataFrame]:
-        """Load raw data from sources"""
+        """Load raw data from sources."""
         logger.info("Loading raw data...")
 
         # Load politician trading data
@@ -222,7 +214,7 @@ class MLPipeline:
     def _preprocess_data(
         self, trading_data: pd.DataFrame, stock_data: pd.DataFrame
     ) -> Dict[str, pd.DataFrame]:
-        """Preprocess raw data"""
+        """Preprocess raw data."""
         logger.info("Preprocessing data...")
 
         # Initialize data processor
@@ -251,7 +243,7 @@ class MLPipeline:
     def _extract_features(
         self, trading_data: pd.DataFrame, stock_data: pd.DataFrame
     ) -> Dict[str, Any]:
-        """Extract features from preprocessed data"""
+        """Extract features from preprocessed data."""
         logger.info("Extracting features...")
 
         # Initialize feature extractors
@@ -294,7 +286,7 @@ class MLPipeline:
         }
 
     def _train_model(self, X: np.ndarray, y: np.ndarray) -> Dict[str, Any]:
-        """Train ensemble model"""
+        """Train ensemble model."""
         logger.info("Training model...")
 
         # Split data
@@ -380,7 +372,7 @@ class MLPipeline:
     def _evaluate_model(
         self, model: StockRecommendationModel, X_test: np.ndarray, y_test: np.ndarray
     ) -> Dict[str, Any]:
-        """Evaluate trained model"""
+        """Evaluate trained model."""
         logger.info("Evaluating model...")
 
         # Generate predictions
@@ -407,9 +399,9 @@ class MLPipeline:
 
         # Calculate AUC if binary classification
         if probabilities.shape[1] == 2:
-            try:
+            try:  # noqa: SIM105
                 evaluation_metrics["test_auc"] = roc_auc_score(y_test, probabilities[:, 1])
-            except:
+            except Exception:
                 pass
 
         logger.info(f"Model evaluation - Test accuracy: {evaluation_metrics['test_accuracy']:.3f}")
@@ -419,7 +411,7 @@ class MLPipeline:
     def _deploy_model(
         self, model: StockRecommendationModel, metrics: Dict[str, float]
     ) -> Dict[str, Any]:
-        """Deploy model (save to disk)"""
+        """Deploy model (save to disk)."""
         logger.info("Deploying model...")
 
         # Save model
@@ -445,7 +437,7 @@ class MLPipeline:
     def run(
         self, start_step: Optional[str] = None, end_step: Optional[str] = None
     ) -> Dict[str, Any]:
-        """Execute pipeline"""
+        """Execute pipeline."""
         logger.info(f"Starting pipeline: {self.config.name} v{self.config.version}")
 
         # Start MLflow run if enabled
@@ -502,7 +494,7 @@ class MLPipeline:
                                 self.artifacts[output_key] = value
 
                 # Log to MLflow
-                if self.experiment_tracker and "metrics" in str(result):
+                if self.experiment_tracker and "metrics" in str(result):  # noqa: SIM102
                     if isinstance(result, dict) and any("metric" in k for k in result.keys()):
                         metrics_dict = result.get(
                             "training_metrics", result.get("evaluation_metrics", {})
@@ -540,7 +532,7 @@ class MLPipeline:
         return {"artifacts": self.artifacts, "metrics": self.metrics, "model": self.model}
 
     def _save_checkpoint(self, step_number: int):
-        """Save pipeline checkpoint"""
+        """Save pipeline checkpoint."""
         checkpoint_path = self.config.cache_dir / f"checkpoint_step_{step_number}.pkl"
 
         checkpoint = {
@@ -560,7 +552,7 @@ class MLPipeline:
         logger.debug(f"Saved checkpoint at step {step_number}")
 
     def load_checkpoint(self, checkpoint_path: Path):
-        """Load pipeline checkpoint"""
+        """Load pipeline checkpoint."""
         with open(checkpoint_path, "rb") as f:
             checkpoint = pickle.load(f)
 
@@ -570,7 +562,7 @@ class MLPipeline:
         logger.info(f"Loaded checkpoint from step {checkpoint['step_number']}")
 
     def _generate_mock_trading_data(self) -> pd.DataFrame:
-        """Generate mock politician trading data for testing"""
+        """Generate mock politician trading data for testing."""
         np.random.seed(42)
         n_records = 500
 
@@ -593,7 +585,7 @@ class MLPipeline:
         return pd.DataFrame(data)
 
     def _generate_mock_stock_data(self) -> pd.DataFrame:
-        """Generate mock stock price data for testing"""
+        """Generate mock stock price data for testing."""
         np.random.seed(42)
         tickers = ["AAPL", "MSFT", "GOOGL", "AMZN", "TSLA"]
         dates = pd.date_range(end=pd.Timestamp.now(), periods=100)
@@ -619,20 +611,20 @@ class MLPipeline:
 
 
 class PipelineExecutor:
-    """Execute and manage multiple pipeline runs"""
+    """Execute and manage multiple pipeline runs."""
 
     def __init__(self, config: PipelineConfig):
         self.config = config
         self.pipelines: Dict[str, MLPipeline] = {}
 
     def create_pipeline(self, name: str) -> MLPipeline:
-        """Create new pipeline instance"""
+        """Create new pipeline instance."""
         pipeline = MLPipeline(self.config)
         self.pipelines[name] = pipeline
         return pipeline
 
     def run_pipeline(self, name: str, **kwargs) -> Dict[str, Any]:
-        """Run specific pipeline"""
+        """Run specific pipeline."""
         if name not in self.pipelines:
             self.pipelines[name] = MLPipeline(self.config)
 
@@ -641,7 +633,7 @@ class PipelineExecutor:
     def run_experiment(
         self, n_runs: int = 5, param_grid: Optional[Dict[str, List]] = None
     ) -> pd.DataFrame:
-        """Run multiple experiments with different parameters"""
+        """Run multiple experiments with different parameters."""
         results = []
 
         for i in range(n_runs):

mcli/ml/models/__init__.py

@@ -1,7 +1,6 @@
-"""ML Models for Stock Recommendation System"""
+"""ML Models for Stock Recommendation System."""
 
-from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict
 
 import torch
 
@@ -27,7 +26,7 @@ _loaded_models: Dict[str, Any] = {}
 
 
 async def load_production_models():
-    """Load production models into memory"""
+    """Load production models into memory."""
     from mcli.ml.config import settings
     from mcli.ml.logging import get_logger
 
@@ -49,7 +48,7 @@ async def load_production_models():
 
 
 async def get_model_by_id(model_id: str):
-    """Get loaded model by ID"""
+    """Get loaded model by ID."""
     from mcli.ml.config import settings
 
     if model_id not in _loaded_models:
@@ -62,7 +61,7 @@ async def get_model_by_id(model_id: str):
 
 
 def initialize_models():
-    """Initialize models on startup"""
+    """Initialize models on startup."""
     from mcli.ml.logging import get_logger
 
     logger = get_logger(__name__)