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

mcli/ml/configs/dvc_config.py

@@ -1,6 +1,5 @@
-"""DVC Configuration for Data Versioning and Pipeline Management"""
+"""DVC Configuration for Data Versioning and Pipeline Management."""
 
-import os
 import subprocess
 from pathlib import Path
 from typing import Any, Dict, List, Optional
@@ -9,7 +8,7 @@ import yaml
 
 
 class DVCConfig:
-    """Configuration class for DVC data versioning and pipeline management"""
+    """Configuration class for DVC data versioning and pipeline management."""
 
     def __init__(self, project_root: Optional[Path] = None):
         self.project_root = project_root or Path(__file__).parent.parent.parent.parent.parent
@@ -18,7 +17,7 @@ class DVCConfig:
         self.models_dir = self.project_root / "models"
 
     def setup_data_directories(self) -> None:
-        """Create and configure data directories for DVC tracking"""
+        """Create and configure data directories for DVC tracking."""
         directories = [
             self.data_dir / "raw",
             self.data_dir / "processed",
@@ -33,7 +32,7 @@ class DVCConfig:
             print(f"Created directory: {directory}")
 
     def add_data_to_dvc(self, data_path: Path, message: Optional[str] = None) -> None:
-        """Add data file or directory to DVC tracking"""
+        """Add data file or directory to DVC tracking."""
         try:
             # Add to DVC
             cmd = ["dvc", "add", str(data_path)]
@@ -64,7 +63,7 @@ class DVCConfig:
         parameters: Optional[Dict[str, Any]] = None,
         metrics: Optional[List[str]] = None,
     ) -> None:
-        """Create a DVC pipeline stage"""
+        """Create a DVC pipeline stage."""
         try:
             cmd = [
                 "dvc",
@@ -99,7 +98,7 @@ class DVCConfig:
             raise
 
     def run_pipeline(self, stage_name: Optional[str] = None) -> None:
-        """Run DVC pipeline or specific stage"""
+        """Run DVC pipeline or specific stage."""
         try:
             cmd = ["dvc", "repro"]
             if stage_name:
@@ -110,7 +109,7 @@ class DVCConfig:
             if result.returncode != 0:
                 raise Exception(f"DVC pipeline run failed: {result.stderr}")
 
-            print(f"DVC pipeline completed successfully")
+            print("DVC pipeline completed successfully")
             if result.stdout:
                 print(result.stdout)
 
@@ -119,7 +118,7 @@ class DVCConfig:
             raise
 
     def get_data_version(self, data_path: Path) -> Optional[str]:
-        """Get the current version hash of a data file"""
+        """Get the current version hash of a data file."""
         try:
             dvc_file = data_path.with_suffix(data_path.suffix + ".dvc")
             if not dvc_file.exists():
@@ -134,7 +133,7 @@ class DVCConfig:
             return None
 
     def pull_data(self, path: Optional[str] = None) -> None:
-        """Pull data from DVC remote storage"""
+        """Pull data from DVC remote storage."""
         try:
             cmd = ["dvc", "pull"]
             if path:
@@ -152,7 +151,7 @@ class DVCConfig:
             raise
 
     def push_data(self, path: Optional[str] = None) -> None:
-        """Push data to DVC remote storage"""
+        """Push data to DVC remote storage."""
         try:
             cmd = ["dvc", "push"]
             if path:
@@ -172,7 +171,7 @@ class DVCConfig:
     def configure_remote_storage(
         self, remote_name: str, storage_url: str, default: bool = True
     ) -> None:
-        """Configure DVC remote storage"""
+        """Configure DVC remote storage."""
         try:
             # Add remote
             cmd = ["dvc", "remote", "add", remote_name, storage_url]
@@ -193,7 +192,7 @@ class DVCConfig:
             raise
 
     def get_pipeline_status(self) -> Dict[str, Any]:
-        """Get status of DVC pipeline"""
+        """Get status of DVC pipeline."""
         try:
             cmd = ["dvc", "status"]
             result = subprocess.run(cmd, capture_output=True, text=True, cwd=self.project_root)
@@ -214,12 +213,12 @@ dvc_config = DVCConfig()
 
 
 def get_dvc_config() -> DVCConfig:
-    """Get the global DVC configuration instance"""
+    """Get the global DVC configuration instance."""
     return dvc_config
 
 
 def setup_dvc() -> None:
-    """Setup DVC data directories and configuration"""
+    """Setup DVC data directories and configuration."""
     dvc_config.setup_data_directories()
     print(f"DVC project root: {dvc_config.project_root}")
     print(f"Data directory: {dvc_config.data_dir}")

mcli/ml/configs/mlflow_config.py

@@ -1,6 +1,5 @@
-"""MLflow Configuration for Stock Recommendation System"""
+"""MLflow Configuration for Stock Recommendation System."""
 
-import os
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -9,7 +8,7 @@ from mlflow.tracking import MlflowClient
 
 
 class MLflowConfig:
-    """Configuration class for MLflow tracking and model registry"""
+    """Configuration class for MLflow tracking and model registry."""
 
     def __init__(
         self,
@@ -23,17 +22,17 @@ class MLflowConfig:
         self._client = None
 
     def _default_tracking_uri(self) -> str:
-        """Get default MLflow tracking URI"""
+        """Get default MLflow tracking URI."""
         project_root = Path(__file__).parent.parent.parent.parent.parent
         return f"file://{project_root}/mlruns"
 
     def _default_artifact_root(self) -> str:
-        """Get default artifact storage location"""
+        """Get default artifact storage location."""
         project_root = Path(__file__).parent.parent.parent.parent.parent
         return f"{project_root}/artifacts"
 
     def setup_tracking(self) -> None:
-        """Initialize MLflow tracking configuration"""
+        """Initialize MLflow tracking configuration."""
         mlflow.set_tracking_uri(self.tracking_uri)
 
         # Create or get experiment
@@ -56,17 +55,17 @@ class MLflowConfig:
 
     @property
     def client(self) -> MlflowClient:
-        """Get MLflow client instance"""
+        """Get MLflow client instance."""
         if self._client is None:
             self._client = MlflowClient(tracking_uri=self.tracking_uri)
         return self._client
 
     def get_model_registry_uri(self) -> str:
-        """Get model registry URI"""
+        """Get model registry URI."""
         return self.tracking_uri
 
     def log_model_metadata(self, run_id: str, metadata: Dict[str, Any]) -> None:
-        """Log additional metadata for a model"""
+        """Log additional metadata for a model."""
         for key, value in metadata.items():
             self.client.log_param(run_id, key, value)
 
@@ -77,7 +76,7 @@ class MLflowConfig:
         tags: Optional[Dict[str, str]] = None,
         description: Optional[str] = None,
     ) -> None:
-        """Register a model in MLflow Model Registry"""
+        """Register a model in MLflow Model Registry."""
         try:
             model_version = mlflow.register_model(model_uri=model_uri, name=model_name, tags=tags)
 
@@ -96,7 +95,7 @@ class MLflowConfig:
     def transition_model_stage(
         self, model_name: str, version: str, stage: str, archive_existing_versions: bool = False
     ) -> None:
-        """Transition model to a different stage"""
+        """Transition model to a different stage."""
         try:
             self.client.transition_model_version_stage(
                 name=model_name,
@@ -116,12 +115,12 @@ mlflow_config = MLflowConfig()
 
 
 def get_mlflow_config() -> MLflowConfig:
-    """Get the global MLflow configuration instance"""
+    """Get the global MLflow configuration instance."""
     return mlflow_config
 
 
 def setup_mlflow() -> None:
-    """Setup MLflow tracking and experiment"""
+    """Setup MLflow tracking and experiment."""
     mlflow_config.setup_tracking()
     print(f"MLflow tracking URI: {mlflow_config.tracking_uri}")
     print(f"Artifact root: {mlflow_config.artifact_root}")

mcli/ml/configs/mlops_manager.py

@@ -1,7 +1,6 @@
-"""Unified MLOps Manager for Stock Recommendation System"""
+"""Unified MLOps Manager for Stock Recommendation System."""
 
 import json
-import os
 import pickle
 from datetime import datetime
 from pathlib import Path
@@ -11,14 +10,13 @@ import joblib
 import mlflow
 import mlflow.pytorch
 import mlflow.sklearn
-from mlflow.tracking import MlflowClient
 
 from .dvc_config import DVCConfig, get_dvc_config
 from .mlflow_config import MLflowConfig, get_mlflow_config
 
 
 class MLOpsManager:
-    """Unified manager for MLflow and DVC operations"""
+    """Unified manager for MLflow and DVC operations."""
 
     def __init__(
         self, mlflow_config: Optional[MLflowConfig] = None, dvc_config: Optional[DVCConfig] = None
@@ -28,7 +26,7 @@ class MLOpsManager:
         self._setup_completed = False
 
     def setup(self) -> None:
-        """Initialize MLOps infrastructure"""
+        """Initialize MLOps infrastructure."""
         if self._setup_completed:
             return
 
@@ -49,7 +47,7 @@ class MLOpsManager:
         tags: Optional[Dict[str, str]] = None,
         description: Optional[str] = None,
     ) -> str:
-        """Start a new MLflow experiment run"""
+        """Start a new MLflow experiment run."""
         if not self._setup_completed:
             self.setup()
 
@@ -62,17 +60,17 @@ class MLOpsManager:
         return run.info.run_id
 
     def log_parameters(self, params: Dict[str, Any]) -> None:
-        """Log parameters to MLflow"""
+        """Log parameters to MLflow."""
         for key, value in params.items():
             mlflow.log_param(key, value)
 
     def log_metrics(self, metrics: Dict[str, float], step: Optional[int] = None) -> None:
-        """Log metrics to MLflow"""
+        """Log metrics to MLflow."""
         for key, value in metrics.items():
             mlflow.log_metric(key, value, step=step)
 
     def log_artifacts(self, artifact_path: Path, artifact_name: Optional[str] = None) -> None:
-        """Log artifacts to MLflow"""
+        """Log artifacts to MLflow."""
         if artifact_path.is_file():
             mlflow.log_artifact(str(artifact_path), artifact_name)
         else:
@@ -87,7 +85,7 @@ class MLOpsManager:
         input_example: Optional[Any] = None,
         metadata: Optional[Dict[str, Any]] = None,
     ) -> str:
-        """Save model locally and log to MLflow"""
+        """Save model locally and log to MLflow."""
         # Create model directory
         model_dir = self.dvc_config.models_dir / model_type / model_name
         model_dir.mkdir(parents=True, exist_ok=True)
@@ -149,7 +147,7 @@ class MLOpsManager:
         description: Optional[str] = None,
         tags: Optional[Dict[str, str]] = None,
     ) -> str:
-        """Register model in MLflow Model Registry"""
+        """Register model in MLflow Model Registry."""
         # Get the current run
         run = mlflow.active_run()
         if not run:
@@ -173,7 +171,7 @@ class MLOpsManager:
     def load_model(
         self, model_name: str, version: Optional[str] = None, stage: Optional[str] = None
     ) -> Any:
-        """Load model from MLflow Model Registry"""
+        """Load model from MLflow Model Registry."""
         if version:
             model_uri = f"models:/{model_name}/{version}"
         elif stage:
@@ -184,11 +182,11 @@ class MLOpsManager:
         return mlflow.pytorch.load_model(model_uri)
 
     def end_run(self, status: str = "FINISHED") -> None:
-        """End the current MLflow run"""
+        """End the current MLflow run."""
         mlflow.end_run(status=status)
 
     def version_data(self, data_path: Path, message: Optional[str] = None) -> str:
-        """Version data using DVC"""
+        """Version data using DVC."""
         self.dvc_config.add_data_to_dvc(data_path, message)
         return self.dvc_config.get_data_version(data_path) or "unknown"
 
@@ -200,7 +198,7 @@ class MLOpsManager:
         outputs: List[str],
         parameters: Optional[List[str]] = None,
     ) -> None:
-        """Create a DVC pipeline stage for ML workflow"""
+        """Create a DVC pipeline stage for ML workflow."""
         command = f"python {script_path}"
 
         self.dvc_config.create_pipeline_stage(
@@ -212,11 +210,11 @@ class MLOpsManager:
         )
 
     def run_ml_pipeline(self, stage_name: Optional[str] = None) -> None:
-        """Run DVC ML pipeline"""
+        """Run DVC ML pipeline."""
         self.dvc_config.run_pipeline(stage_name)
 
     def get_experiment_metrics(self, experiment_name: str) -> List[Dict[str, Any]]:
-        """Get metrics from all runs in an experiment"""
+        """Get metrics from all runs in an experiment."""
         experiment = mlflow.get_experiment_by_name(experiment_name)
         if not experiment:
             return []
@@ -227,7 +225,7 @@ class MLOpsManager:
     def compare_models(
         self, model_names: List[str], metric_name: str = "accuracy"
     ) -> Dict[str, Any]:
-        """Compare models by a specific metric"""
+        """Compare models by a specific metric."""
         comparison = {}
 
         for model_name in model_names:
@@ -252,13 +250,13 @@ class MLOpsManager:
         return comparison
 
     def cleanup_old_runs(self, days_old: int = 30) -> None:
-        """Clean up old experiment runs"""
+        """Clean up old experiment runs."""
         # This would implement cleanup logic for old runs
         # For now, just a placeholder
         print(f"Cleanup of runs older than {days_old} days would be implemented here")
 
     def get_system_info(self) -> Dict[str, Any]:
-        """Get MLOps system information"""
+        """Get MLOps system information."""
         return {
             "mlflow_tracking_uri": self.mlflow_config.tracking_uri,
             "mlflow_experiment": self.mlflow_config.experiment_name,
@@ -275,7 +273,7 @@ mlops_manager = MLOpsManager()
 
 
 def get_mlops_manager() -> MLOpsManager:
-    """Get the global MLOps manager instance"""
+    """Get the global MLOps manager instance."""
     return mlops_manager
 
 

mcli/ml/dashboard/__init__.py

@@ -1,12 +1,12 @@
-"""ML Dashboard for real-time monitoring"""
+"""ML Dashboard for real-time monitoring."""
 
-from .app import main
+from .app import main as app_main
 from .cli import app as cli_app
 
 
 def main():
-    """Main entry point for dashboard CLI"""
+    """Main entry point for dashboard CLI."""
     cli_app()
 
 
-__all__ = ["main", "cli_app"]
+__all__ = ["main", "cli_app", "app_main"]

mcli/ml/dashboard/app.py

@@ -1,6 +1,5 @@
-"""Streamlit dashboard for ML system monitoring"""
+"""Streamlit dashboard for ML system monitoring."""
 
-import asyncio
 import time
 from datetime import datetime, timedelta
 
@@ -16,16 +15,7 @@ from mcli.ml.cache import cache_manager
 from mcli.ml.config import settings
 from mcli.ml.dashboard.common import setup_page_config
 from mcli.ml.dashboard.styles import apply_dashboard_styles
-from mcli.ml.database.models import (
-    BacktestResult,
-    Model,
-    ModelStatus,
-    Portfolio,
-    Prediction,
-    StockData,
-    Trade,
-    User,
-)
+from mcli.ml.database.models import Model, ModelStatus, Portfolio, Prediction, User
 from mcli.ml.database.session import SessionLocal
 
 # Page config - must be first
@@ -37,7 +27,7 @@ apply_dashboard_styles()
 
 @st.cache_data(ttl=30)
 def get_system_metrics():
-    """Get real-time system metrics"""
+    """Get real-time system metrics."""
     db = SessionLocal()
 
     try:
@@ -62,7 +52,7 @@ def get_system_metrics():
         )
 
         # Portfolio metrics
-        active_portfolios = db.query(Portfolio).filter(Portfolio.is_active == True).count()
+        active_portfolios = db.query(Portfolio).filter(Portfolio.is_active is True).count()
 
         return {
             "total_models": total_models,
@@ -80,7 +70,7 @@ def get_system_metrics():
 
 @st.cache_data(ttl=60)
 def get_model_performance():
-    """Get model performance data"""
+    """Get model performance data."""
     db = SessionLocal()
 
     try:
@@ -104,7 +94,7 @@ def get_model_performance():
 
 @st.cache_data(ttl=30)
 def get_recent_predictions():
-    """Get recent predictions"""
+    """Get recent predictions."""
     db = SessionLocal()
 
     try:
@@ -131,11 +121,11 @@ def get_recent_predictions():
 
 @st.cache_data(ttl=60)
 def get_portfolio_performance():
-    """Get portfolio performance data"""
+    """Get portfolio performance data."""
     db = SessionLocal()
 
     try:
-        portfolios = db.query(Portfolio).filter(Portfolio.is_active == True).all()
+        portfolios = db.query(Portfolio).filter(Portfolio.is_active is True).all()
 
         data = []
         for portfolio in portfolios:
@@ -155,25 +145,25 @@ def get_portfolio_performance():
 
 
 def check_api_health():
-    """Check API health"""
+    """Check API health."""
     try:
         response = requests.get(f"http://localhost:{settings.api.port}/health", timeout=5)
         return response.status_code == 200
-    except:
+    except Exception:
         return False
 
 
 def check_redis_health():
-    """Check Redis health"""
+    """Check Redis health."""
     try:
         cache_manager.initialize()
         return cache_manager.redis_client.ping() if cache_manager.redis_client else False
-    except:
+    except Exception:
         return False
 
 
 def main():
-    """Main dashboard function"""
+    """Main dashboard function."""
 
     # Title and header
     st.title("🤖 MCLI ML System Dashboard")
@@ -213,7 +203,7 @@ def main():
 
 
 def show_overview():
-    """Show overview dashboard"""
+    """Show overview dashboard."""
     st.header("System Overview")
 
     # Get metrics
@@ -268,7 +258,7 @@ def show_overview():
 
 
 def show_models():
-    """Show models dashboard"""
+    """Show models dashboard."""
     st.header("Model Management")
 
     # Model performance table
@@ -288,7 +278,7 @@ def show_models():
 
 
 def show_predictions():
-    """Show predictions dashboard"""
+    """Show predictions dashboard."""
     st.header("Predictions Analysis")
 
     pred_data = get_recent_predictions()
@@ -347,7 +337,7 @@ def show_predictions():
 
 
 def show_portfolios():
-    """Show portfolios dashboard"""
+    """Show portfolios dashboard."""
     st.header("Portfolio Performance")
 
     portfolio_data = get_portfolio_performance()
@@ -382,7 +372,7 @@ def show_portfolios():
 
 
 def show_system_health():
-    """Show system health dashboard"""
+    """Show system health dashboard."""
     st.header("System Health")
 
     # Check various system components
@@ -438,7 +428,7 @@ def show_system_health():
 
 
 def show_live_monitoring():
-    """Show live monitoring with real-time updates"""
+    """Show live monitoring with real-time updates."""
     st.header("Live Monitoring")
 
     # Real-time metrics placeholder
@@ -454,7 +444,7 @@ def show_live_monitoring():
 
     # Auto-update every 5 seconds
     if st.button("Start Live Monitoring"):
-        for i in range(60):  # Run for 5 minutes
+        for _i in range(60):  # Run for 5 minutes
             # Update metrics
             metrics = get_system_metrics()
             with metrics_placeholder.container():