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

mcli/ml/cache.py

@@ -1,12 +1,11 @@
-"""Redis caching layer for ML system"""
+"""Redis caching layer for ML system."""
 
 import asyncio
 import hashlib
 import json
 import pickle
-from datetime import timedelta
 from functools import wraps
-from typing import Any, Callable, Optional, Union
+from typing import Any, Callable, Optional
 
 import redis
 from redis import asyncio as aioredis
@@ -18,7 +17,7 @@ logger = get_logger(__name__)
 
 
 class CacheManager:
-    """Manage Redis cache connections and operations"""
+    """Manage Redis cache connections and operations."""
 
     def __init__(self):
         self.redis_client: Optional[redis.Redis] = None
@@ -26,7 +25,7 @@ class CacheManager:
         self._initialized = False
 
     def initialize(self):
-        """Initialize Redis connections"""
+        """Initialize Redis connections."""
         if self._initialized:
             return
 
@@ -59,7 +58,7 @@ class CacheManager:
             self.redis_client = None
 
     async def initialize_async(self):
-        """Initialize async Redis connection"""
+        """Initialize async Redis connection."""
         if self.async_redis_client:
             return
 
@@ -80,41 +79,41 @@ class CacheManager:
             self.async_redis_client = None
 
     def _make_key(self, key: str, prefix: str = "mcli:ml:") -> str:
-        """Create cache key with prefix"""
+        """Create cache key with prefix."""
         return f"{prefix}{key}"
 
     def _serialize(self, value: Any) -> bytes:
-        """Serialize value for storage"""
-        try:
+        """Serialize value for storage."""
+        try:  # noqa: SIM105
             # Try JSON first (for simple types)
             if isinstance(value, (dict, list, str, int, float, bool, type(None))):
                 return json.dumps(value).encode("utf-8")
-        except:
+        except Exception:
             pass
 
         # Fall back to pickle for complex objects
         return pickle.dumps(value)
 
     def _deserialize(self, value: bytes) -> Any:
-        """Deserialize value from storage"""
+        """Deserialize value from storage."""
         if value is None:
             return None
 
         # Try JSON first
-        try:
+        try:  # noqa: SIM105
             return json.loads(value.decode("utf-8"))
-        except:
+        except Exception:
             pass
 
         # Fall back to pickle
         try:
             return pickle.loads(value)
-        except:
+        except Exception:
             logger.error("Failed to deserialize cache value")
             return None
 
     def set(self, key: str, value: Any, expire: int = 3600) -> bool:
-        """Set cache value"""
+        """Set cache value."""
         if not self.redis_client:
             self.initialize()
 
@@ -130,7 +129,7 @@ class CacheManager:
             return False
 
     def get(self, key: str) -> Any:
-        """Get cache value"""
+        """Get cache value."""
         if not self.redis_client:
             self.initialize()
 
@@ -146,7 +145,7 @@ class CacheManager:
             return None
 
     async def set_async(self, key: str, value: Any, expire: int = 3600) -> bool:
-        """Set cache value asynchronously"""
+        """Set cache value asynchronously."""
         if not self.async_redis_client:
             await self.initialize_async()
 
@@ -163,7 +162,7 @@ class CacheManager:
             return False
 
     async def get_async(self, key: str) -> Any:
-        """Get cache value asynchronously"""
+        """Get cache value asynchronously."""
         if not self.async_redis_client:
             await self.initialize_async()
 
@@ -179,7 +178,7 @@ class CacheManager:
             return None
 
     def delete(self, key: str) -> bool:
-        """Delete cache entry"""
+        """Delete cache entry."""
         if not self.redis_client:
             return False
 
@@ -191,7 +190,7 @@ class CacheManager:
             return False
 
     async def delete_async(self, key: str) -> bool:
-        """Delete cache entry asynchronously"""
+        """Delete cache entry asynchronously."""
         if not self.async_redis_client:
             return False
 
@@ -204,7 +203,7 @@ class CacheManager:
             return False
 
     def invalidate_pattern(self, pattern: str) -> int:
-        """Invalidate all keys matching pattern"""
+        """Invalidate all keys matching pattern."""
         if not self.redis_client:
             return 0
 
@@ -219,7 +218,7 @@ class CacheManager:
             return 0
 
     def get_or_set(self, key: str, func: Callable, expire: int = 3600) -> Any:
-        """Get from cache or compute and set"""
+        """Get from cache or compute and set."""
         value = self.get(key)
         if value is not None:
             return value
@@ -229,7 +228,7 @@ class CacheManager:
         return value
 
     async def get_or_set_async(self, key: str, func: Callable, expire: int = 3600) -> Any:
-        """Get from cache or compute and set asynchronously"""
+        """Get from cache or compute and set asynchronously."""
         value = await self.get_async(key)
         if value is not None:
             return value
@@ -243,13 +242,13 @@ class CacheManager:
         return value
 
     def close(self):
-        """Close Redis connections"""
+        """Close Redis connections."""
         if self.redis_client:
             self.redis_client.close()
             self.redis_client = None
 
     async def close_async(self):
-        """Close async Redis connection"""
+        """Close async Redis connection."""
         if self.async_redis_client:
             await self.async_redis_client.close()
             self.async_redis_client = None
@@ -261,7 +260,7 @@ cache_manager = CacheManager()
 
 # Decorator for caching function results
 def cached(expire: int = 3600, key_prefix: str = None):
-    """Decorator to cache function results"""
+    """Decorator to cache function results."""
 
     def decorator(func: Callable):
         @wraps(func)
@@ -334,19 +333,19 @@ def cached(expire: int = 3600, key_prefix: str = None):
 
 # Cache invalidation helpers
 def invalidate_user_cache(user_id: str):
-    """Invalidate all cache entries for a user"""
+    """Invalidate all cache entries for a user."""
     pattern = f"user:{user_id}:*"
     return cache_manager.invalidate_pattern(pattern)
 
 
 def invalidate_model_cache(model_id: str):
-    """Invalidate all cache entries for a model"""
+    """Invalidate all cache entries for a model."""
     pattern = f"model:{model_id}:*"
     return cache_manager.invalidate_pattern(pattern)
 
 
 def invalidate_prediction_cache(prediction_id: str = None):
-    """Invalidate prediction cache"""
+    """Invalidate prediction cache."""
     if prediction_id:
         pattern = f"prediction:{prediction_id}:*"
     else:
@@ -356,17 +355,17 @@ def invalidate_prediction_cache(prediction_id: str = None):
 
 # Convenience functions
 async def init_cache():
-    """Initialize cache manager"""
+    """Initialize cache manager."""
     await cache_manager.initialize_async()
 
 
 async def close_cache():
-    """Close cache connections"""
+    """Close cache connections."""
     await cache_manager.close_async()
 
 
 async def check_cache_health() -> bool:
-    """Check if cache is healthy"""
+    """Check if cache is healthy."""
     try:
         if not cache_manager.async_redis_client:
             await cache_manager.initialize_async()
@@ -375,20 +374,20 @@ async def check_cache_health() -> bool:
             await cache_manager.async_redis_client.ping()
             return True
         return False
-    except:
+    except Exception:
         return False
 
 
 def cache_set(key: str, value: Any, expire: int = 3600):
-    """Set cache value"""
+    """Set cache value."""
     return cache_manager.set(key, value, expire)
 
 
 def cache_get(key: str):
-    """Get cache value"""
+    """Get cache value."""
     return cache_manager.get(key)
 
 
 def cache_delete(key: str):
-    """Delete cache entry"""
+    """Delete cache entry."""
     return cache_manager.delete(key)

mcli/ml/cli/__init__.py

@@ -1,4 +1,4 @@
-"""CLI interface for ML system"""
+"""CLI interface for ML system."""
 
 from .main import app
 

mcli/ml/cli/main.py

@@ -1,4 +1,4 @@
-"""Main CLI interface for ML system"""
+"""Main CLI interface for ML system."""
 
 import asyncio
 from pathlib import Path
@@ -14,10 +14,7 @@ from mcli.ml.config import create_settings, settings
 from mcli.ml.experimentation.ab_testing import ABTestingFramework
 from mcli.ml.mlops.pipeline_orchestrator import MLPipeline, PipelineConfig
 from mcli.ml.monitoring.drift_detection import ModelMonitor
-from mcli.ml.optimization.portfolio_optimizer import (
-    AdvancedPortfolioOptimizer,
-    OptimizationObjective,
-)
+from mcli.ml.optimization.portfolio_optimizer import OptimizationObjective
 
 app = typer.Typer(
     name="mcli-ml",
@@ -41,9 +38,9 @@ def train(
         False, "--dry-run", help="Validate configuration without training"
     ),
 ):
-    """Train ML models for stock recommendations"""
+    """Train ML models for stock recommendations."""
 
-    console.print(f"[bold blue]Training ML Model[/bold blue]")
+    console.print("[bold blue]Training ML Model[/bold blue]")
     console.print(f"Experiment: {experiment_name}")
 
     # Override settings if provided
@@ -66,7 +63,7 @@ def train(
 
     if dry_run:
         console.print("[yellow]Dry run mode - validating configuration...[/yellow]")
-        pipeline = MLPipeline(pipeline_config)
+        MLPipeline(pipeline_config)
         console.print("[green]✓ Configuration valid[/green]")
         return
 
@@ -114,9 +111,9 @@ def serve(
     reload: bool = typer.Option(False, "--reload", help="Enable auto-reload"),
     model_path: Optional[Path] = typer.Option(None, "--model", help="Path to model file"),
 ):
-    """Serve trained models via REST API"""
+    """Serve trained models via REST API."""
 
-    console.print(f"[bold blue]Starting Model Server[/bold blue]")
+    console.print("[bold blue]Starting Model Server[/bold blue]")
     console.print(f"Host: {host}")
     console.print(f"Port: {port}")
     console.print(f"Workers: {workers}")
@@ -143,9 +140,9 @@ def backtest(
     commission: float = typer.Option(0.001, "--commission", help="Commission rate"),
     output_dir: Optional[Path] = typer.Option(None, "--output", help="Output directory"),
 ):
-    """Run backtesting on trading strategies"""
+    """Run backtesting on trading strategies."""
 
-    console.print(f"[bold blue]Running Backtest[/bold blue]")
+    console.print("[bold blue]Running Backtest[/bold blue]")
     console.print(f"Strategy: {strategy}")
     console.print(f"Initial Capital: ${initial_capital:,.2f}")
 
@@ -157,7 +154,7 @@ def backtest(
     )
 
     async def run_backtest():
-        engine = BacktestEngine(config)
+        BacktestEngine(config)
 
         with Progress(
             SpinnerColumn(),
@@ -203,14 +200,14 @@ def optimize(
     max_weight: float = typer.Option(0.4, "--max-weight", help="Maximum weight per asset"),
     risk_free_rate: float = typer.Option(0.02, "--risk-free-rate", help="Risk-free rate"),
 ):
-    """Optimize portfolio allocation"""
+    """Optimize portfolio allocation."""
 
-    console.print(f"[bold blue]Portfolio Optimization[/bold blue]")
+    console.print("[bold blue]Portfolio Optimization[/bold blue]")
     console.print(f"Objective: {objective}")
     console.print(f"Tickers: {', '.join(tickers)}")
 
     try:
-        obj_enum = OptimizationObjective(objective)
+        OptimizationObjective(objective)
     except ValueError:
         console.print(f"[red]Invalid objective: {objective}[/red]")
         console.print(
@@ -272,12 +269,12 @@ def monitor(
     check_drift: bool = typer.Option(True, "--drift", help="Check for data drift"),
     generate_report: bool = typer.Option(False, "--report", help="Generate monitoring report"),
 ):
-    """Monitor model performance and data drift"""
+    """Monitor model performance and data drift."""
 
-    console.print(f"[bold blue]Model Monitoring[/bold blue]")
+    console.print("[bold blue]Model Monitoring[/bold blue]")
     console.print(f"Model: {model_name}")
 
-    monitor = ModelMonitor(model_name)
+    ModelMonitor(model_name)
 
     if check_drift:
         console.print(
@@ -296,9 +293,9 @@ def experiment(
     experiment_id: Optional[str] = typer.Option(None, "--id", help="Experiment ID"),
     name: Optional[str] = typer.Option(None, "--name", help="Experiment name"),
 ):
-    """Manage A/B testing experiments"""
+    """Manage A/B testing experiments."""
 
-    console.print(f"[bold blue]A/B Testing Experiment[/bold blue]")
+    console.print("[bold blue]A/B Testing Experiment[/bold blue]")
     console.print(f"Action: {action}")
 
     framework = ABTestingFramework()
@@ -339,7 +336,7 @@ def experiment(
 
 @app.command()
 def status():
-    """Show system status and health"""
+    """Show system status and health."""
 
     status_table = Table(title="ML System Status")
     status_table.add_column("Component", style="cyan")
@@ -376,11 +373,11 @@ def config(
     environment: Optional[str] = typer.Option(None, "--env", help="Set environment"),
     debug: Optional[bool] = typer.Option(None, "--debug", help="Set debug mode"),
 ):
-    """Manage system configuration"""
+    """Manage system configuration."""
     global settings
 
     if show:
-        console.print(f"[bold blue]Current Configuration[/bold blue]")
+        console.print("[bold blue]Current Configuration[/bold blue]")
 
         # Show all settings in a tree structure
         console.print(f"Environment: {settings.environment}")

mcli/ml/config/__init__.py

@@ -1,4 +1,4 @@
-"""Configuration management for ML system"""
+"""Configuration management for ML system."""
 
 from .settings import (
     APISettings,

mcli/ml/config/settings.py

@@ -1,7 +1,6 @@
-"""Configuration management for ML system"""
+"""Configuration management for ML system."""
 
 import logging
-import os
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -12,7 +11,7 @@ logger = logging.getLogger(__name__)
 
 
 class DatabaseSettings(BaseSettings):
-    """Database configuration"""
+    """Database configuration."""
 
     model_config = SettingsConfigDict(env_prefix="DB_")
 
@@ -29,7 +28,7 @@ class DatabaseSettings(BaseSettings):
 
     @property
     def url(self) -> str:
-        """Get database URL"""
+        """Get database URL."""
         # Use SQLite for local development if no user is specified
         if not self.user:
             return f"sqlite:///{self.name}"
@@ -37,7 +36,7 @@ class DatabaseSettings(BaseSettings):
 
     @property
     def async_url(self) -> str:
-        """Get async database URL"""
+        """Get async database URL."""
         # Use aiosqlite for local development if no user is specified
         if not self.user:
             return f"sqlite+aiosqlite:///{self.name}"
@@ -47,7 +46,7 @@ class DatabaseSettings(BaseSettings):
 
 
 class RedisSettings(BaseSettings):
-    """Redis configuration"""
+    """Redis configuration."""
 
     model_config = SettingsConfigDict(env_prefix="REDIS_")
 
@@ -62,13 +61,13 @@ class RedisSettings(BaseSettings):
 
     @property
     def url(self) -> str:
-        """Get Redis URL"""
+        """Get Redis URL."""
         auth_part = f":{self.password}@" if self.password else ""
         return f"redis://{auth_part}{self.host}:{self.port}/{self.db}"
 
 
 class MLflowSettings(BaseSettings):
-    """MLflow configuration"""
+    """MLflow configuration."""
 
     model_config = SettingsConfigDict(env_prefix="MLFLOW_")
 
@@ -86,7 +85,7 @@ class MLflowSettings(BaseSettings):
 
 
 class ModelSettings(BaseSettings):
-    """Model configuration"""
+    """Model configuration."""
 
     model_config = SettingsConfigDict(env_prefix="MODEL_")
 
@@ -110,12 +109,12 @@ class ModelSettings(BaseSettings):
     @field_validator("model_dir", "cache_dir", mode="before")
     @classmethod
     def validate_paths(cls, v):
-        """Ensure paths are Path objects"""
+        """Ensure paths are Path objects."""
         return Path(v) if not isinstance(v, Path) else v
 
 
 class DataSettings(BaseSettings):
-    """Data configuration"""
+    """Data configuration."""
 
     model_config = SettingsConfigDict(env_prefix="DATA_")
 
@@ -137,12 +136,12 @@ class DataSettings(BaseSettings):
     @field_validator("data_dir", "raw_dir", "processed_dir", "dvc_cache_dir", mode="before")
     @classmethod
     def validate_paths(cls, v):
-        """Ensure paths are Path objects"""
+        """Ensure paths are Path objects."""
         return Path(v) if not isinstance(v, Path) else v
 
 
 class APISettings(BaseSettings):
-    """API configuration"""
+    """API configuration."""
 
     model_config = SettingsConfigDict(env_prefix="API_")
 
@@ -166,7 +165,7 @@ class APISettings(BaseSettings):
 
 
 class MonitoringSettings(BaseSettings):
-    """Monitoring configuration"""
+    """Monitoring configuration."""
 
     model_config = SettingsConfigDict(env_prefix="MONITORING_")
 
@@ -188,7 +187,7 @@ class MonitoringSettings(BaseSettings):
 
 
 class SecuritySettings(BaseSettings):
-    """Security configuration"""
+    """Security configuration."""
 
     model_config = SettingsConfigDict(env_prefix="SECURITY_")
 
@@ -207,12 +206,12 @@ class SecuritySettings(BaseSettings):
     @field_validator("ssl_cert_path", "ssl_key_path", mode="before")
     @classmethod
     def validate_ssl_paths(cls, v):
-        """Ensure SSL paths are Path objects if provided"""
+        """Ensure SSL paths are Path objects if provided."""
         return Path(v) if v and not isinstance(v, Path) else v
 
 
 class Settings(BaseSettings):
-    """Main application settings"""
+    """Main application settings."""
 
     model_config = SettingsConfigDict(
         env_file=".env", env_file_encoding="utf-8", case_sensitive=False, extra="ignore"
@@ -237,7 +236,7 @@ class Settings(BaseSettings):
     @field_validator("environment")
     @classmethod
     def validate_environment(cls, v):
-        """Validate environment value"""
+        """Validate environment value."""
         valid_envs = ["development", "staging", "production"]
         if v not in valid_envs:
             raise ValueError(f"Environment must be one of {valid_envs}")
@@ -248,7 +247,7 @@ class Settings(BaseSettings):
         self._create_directories()
 
     def _create_directories(self):
-        """Create necessary directories"""
+        """Create necessary directories."""
         directories = [
             self.model.model_dir,
             self.model.cache_dir,
@@ -263,16 +262,16 @@ class Settings(BaseSettings):
 
     @property
     def is_production(self) -> bool:
-        """Check if running in production"""
+        """Check if running in production."""
         return self.environment == "production"
 
     @property
     def is_development(self) -> bool:
-        """Check if running in development"""
+        """Check if running in development."""
         return self.environment == "development"
 
     def get_database_config(self) -> Dict[str, Any]:
-        """Get database configuration for SQLAlchemy"""
+        """Get database configuration for SQLAlchemy."""
         return {
             "pool_size": self.database.pool_size,
             "max_overflow": self.database.max_overflow,
@@ -282,7 +281,7 @@ class Settings(BaseSettings):
         }
 
     def get_redis_config(self) -> Dict[str, Any]:
-        """Get Redis configuration"""
+        """Get Redis configuration."""
         return {
             "host": self.redis.host,
             "port": self.redis.port,
@@ -299,12 +298,12 @@ settings = Settings()
 
 
 def get_settings() -> Settings:
-    """Get settings instance (for dependency injection)"""
+    """Get settings instance (for dependency injection)."""
     return settings
 
 
 def update_settings(**kwargs) -> Settings:
-    """Update settings with new values"""
+    """Update settings with new values."""
     global settings
 
     # Create new settings instance with updated values
@@ -317,7 +316,7 @@ def update_settings(**kwargs) -> Settings:
 
 # Environment-specific configurations
 def get_development_config() -> Dict[str, Any]:
-    """Get development-specific configuration overrides"""
+    """Get development-specific configuration overrides."""
     return {
         "debug": True,
         "database": {
@@ -341,7 +340,7 @@ def get_development_config() -> Dict[str, Any]:
 
 
 def get_production_config() -> Dict[str, Any]:
-    """Get production-specific configuration overrides"""
+    """Get production-specific configuration overrides."""
     return {
         "debug": False,
         "monitoring": {
@@ -356,7 +355,7 @@ def get_production_config() -> Dict[str, Any]:
 
 
 def get_testing_config() -> Dict[str, Any]:
-    """Get testing-specific configuration overrides"""
+    """Get testing-specific configuration overrides."""
     return {
         "debug": True,
         "database": {
@@ -374,7 +373,7 @@ def get_testing_config() -> Dict[str, Any]:
 
 # Configuration factory
 def create_settings(environment: str = "development") -> Settings:
-    """Create settings for specific environment"""
+    """Create settings for specific environment."""
     base_config = {}
 
     if environment == "development":

mcli/ml/configs/__init__.py

@@ -1,4 +1,4 @@
-"""ML Configuration Module"""
+"""ML Configuration Module."""
 
 from .dvc_config import DVCConfig, get_dvc_config, setup_dvc
 from .mlflow_config import MLflowConfig, get_mlflow_config, setup_mlflow