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

mcli/ml/api/routers/model_router.py

@@ -1,18 +1,17 @@
-"""Model management API routes"""
+"""Model management API routes."""
 
 from datetime import datetime
 from typing import List, Optional
 from uuid import UUID
 
 from fastapi import APIRouter, Depends, File, HTTPException, Query, UploadFile, status
-from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 from mcli.ml.api.schemas import ModelCreate, ModelMetrics, ModelResponse, ModelUpdate
-from mcli.ml.auth import Permission, get_current_active_user, require_role
+from mcli.ml.auth import get_current_active_user, require_role
 from mcli.ml.cache import cached
 from mcli.ml.database.models import Model, ModelStatus, User, UserRole
-from mcli.ml.database.session import get_async_db, get_db
+from mcli.ml.database.session import get_db
 from mcli.ml.tasks import train_model_task
 
 router = APIRouter()
@@ -27,7 +26,7 @@ async def list_models(
     current_user: User = Depends(get_current_active_user),
     db: Session = Depends(get_db),
 ):
-    """List all available models"""
+    """List all available models."""
     query = db.query(Model)
 
     if status:
@@ -44,7 +43,7 @@ async def get_model(
     current_user: User = Depends(get_current_active_user),
     db: Session = Depends(get_db),
 ):
-    """Get specific model details"""
+    """Get specific model details."""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
@@ -59,7 +58,7 @@ async def create_model(
     current_user: User = Depends(require_role(UserRole.ANALYST, UserRole.ADMIN)),
     db: Session = Depends(get_db),
 ):
-    """Create a new model"""
+    """Create a new model."""
     model = Model(
         **model_data.dict(), created_by=current_user.username, status=ModelStatus.TRAINING
     )
@@ -81,7 +80,7 @@ async def update_model(
     current_user: User = Depends(require_role(UserRole.ANALYST, UserRole.ADMIN)),
     db: Session = Depends(get_db),
 ):
-    """Update model metadata"""
+    """Update model metadata."""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
@@ -104,7 +103,7 @@ async def deploy_model(
     current_user: User = Depends(require_role(UserRole.ANALYST, UserRole.ADMIN)),
     db: Session = Depends(get_db),
 ):
-    """Deploy model to production"""
+    """Deploy model to production."""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
@@ -132,7 +131,7 @@ async def archive_model(
     current_user: User = Depends(require_role(UserRole.ADMIN)),
     db: Session = Depends(get_db),
 ):
-    """Archive a model"""
+    """Archive a model."""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
@@ -151,7 +150,7 @@ async def get_model_metrics(
     current_user: User = Depends(get_current_active_user),
     db: Session = Depends(get_db),
 ):
-    """Get model performance metrics"""
+    """Get model performance metrics."""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
@@ -176,7 +175,7 @@ async def retrain_model(
     current_user: User = Depends(require_role(UserRole.ANALYST, UserRole.ADMIN)),
     db: Session = Depends(get_db),
 ):
-    """Retrain an existing model"""
+    """Retrain an existing model."""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
@@ -202,7 +201,7 @@ async def upload_model_artifact(
     current_user: User = Depends(require_role(UserRole.ANALYST, UserRole.ADMIN)),
     db: Session = Depends(get_db),
 ):
-    """Upload model artifact file"""
+    """Upload model artifact file."""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
@@ -224,7 +223,7 @@ async def delete_model(
     current_user: User = Depends(require_role(UserRole.ADMIN)),
     db: Session = Depends(get_db),
 ):
-    """Delete a model"""
+    """Delete a model."""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
@@ -248,7 +247,7 @@ async def download_model(
     current_user: User = Depends(get_current_active_user),
     db: Session = Depends(get_db),
 ):
-    """Download model artifact"""
+    """Download model artifact."""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:

mcli/ml/api/routers/monitoring_router.py

@@ -1,4 +1,4 @@
-"""Monitoring API routes"""
+"""Monitoring API routes."""
 
 from fastapi import APIRouter, Depends
 
@@ -10,5 +10,5 @@ router = APIRouter()
 
 @router.get("/drift")
 async def get_drift_status(current_user: User = Depends(get_current_active_user)):
-    """Get drift monitoring status"""
+    """Get drift monitoring status."""
     return {"drift_detected": False}

mcli/ml/api/routers/portfolio_router.py

@@ -1,4 +1,4 @@
-"""Portfolio management API routes"""
+"""Portfolio management API routes."""
 
 from fastapi import APIRouter, Depends
 
@@ -10,5 +10,5 @@ router = APIRouter()
 
 @router.get("/")
 async def list_portfolios(current_user: User = Depends(get_current_active_user)):
-    """List user portfolios"""
+    """List user portfolios."""
     return {"portfolios": []}

mcli/ml/api/routers/prediction_router.py

@@ -1,14 +1,15 @@
-"""Prediction API routes"""
+"""Prediction API routes."""
 
 from datetime import datetime, timedelta
 from typing import List, Optional
 from uuid import UUID
 
+import numpy as np
 from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Query, status
 from pydantic import BaseModel
 from sqlalchemy.orm import Session
 
-from mcli.ml.api.schemas import BatchPredictionRequest, PredictionRequest, PredictionResponse
+from mcli.ml.api.schemas import BatchPredictionRequest, PredictionResponse
 from mcli.ml.auth import get_current_active_user
 from mcli.ml.cache import cache_set, cached
 from mcli.ml.database.models import Model, Prediction, StockData, User
@@ -32,7 +33,7 @@ async def create_prediction(
     current_user: User = Depends(get_current_active_user),
     db: Session = Depends(get_db),
 ):
-    """Create a new prediction"""
+    """Create a new prediction."""
 
     # Get model (use default if not specified)
     if request.model_id:
@@ -107,7 +108,7 @@ async def create_batch_predictions(
     current_user: User = Depends(get_current_active_user),
     db: Session = Depends(get_db),
 ):
-    """Create predictions for multiple tickers"""
+    """Create predictions for multiple tickers."""
     predictions = []
 
     for ticker_data in request.tickers:
@@ -135,7 +136,7 @@ async def list_predictions(
     current_user: User = Depends(get_current_active_user),
     db: Session = Depends(get_db),
 ):
-    """List user's predictions"""
+    """List user's predictions."""
     query = db.query(Prediction).filter(Prediction.user_id == current_user.id)
 
     if ticker:
@@ -159,7 +160,7 @@ async def get_prediction(
     current_user: User = Depends(get_current_active_user),
     db: Session = Depends(get_db),
 ):
-    """Get specific prediction details"""
+    """Get specific prediction details."""
     prediction = (
         db.query(Prediction)
         .filter(Prediction.id == prediction_id, Prediction.user_id == current_user.id)
@@ -178,7 +179,7 @@ async def get_prediction_outcome(
     current_user: User = Depends(get_current_active_user),
     db: Session = Depends(get_db),
 ):
-    """Get actual outcome of a prediction"""
+    """Get actual outcome of a prediction."""
     prediction = (
         db.query(Prediction)
         .filter(Prediction.id == prediction_id, Prediction.user_id == current_user.id)
@@ -221,7 +222,7 @@ async def get_latest_recommendations(
     current_user: User = Depends(get_current_active_user),
     db: Session = Depends(get_db),
 ):
-    """Get latest stock recommendations"""
+    """Get latest stock recommendations."""
     # Get recent predictions with high confidence
     predictions = (
         db.query(Prediction)
@@ -254,7 +255,7 @@ async def get_latest_recommendations(
 
 
 async def update_stock_data(ticker: str, db: Session):
-    """Background task to update stock data"""
+    """Background task to update stock data."""
     # In real implementation, fetch latest stock data
     stock = db.query(StockData).filter(StockData.ticker == ticker).first()
     if stock:

mcli/ml/api/routers/trade_router.py

@@ -1,4 +1,4 @@
-"""Trading API routes"""
+"""Trading API routes."""
 
 from fastapi import APIRouter, Depends
 
@@ -12,5 +12,5 @@ router = APIRouter()
 async def get_politician_trades(
     politician_id: str, current_user: User = Depends(get_current_active_user)
 ):
-    """Get politician trades"""
+    """Get politician trades."""
     return {"politician_id": politician_id, "trades": []}

mcli/ml/api/routers/websocket_router.py

@@ -1,10 +1,9 @@
-"""WebSocket API routes for real-time updates"""
+"""WebSocket API routes for real-time updates."""
 
 import asyncio
-import json
 from typing import Dict, Set
 
-from fastapi import APIRouter, Depends, WebSocket, WebSocketDisconnect
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
 
 from mcli.ml.logging import get_logger
 
@@ -13,7 +12,7 @@ logger = get_logger(__name__)
 
 
 class ConnectionManager:
-    """Manage WebSocket connections"""
+    """Manage WebSocket connections."""
 
     def __init__(self):
         self.active_connections: Dict[str, Set[WebSocket]] = {}
@@ -36,7 +35,7 @@ class ConnectionManager:
             for connection in self.active_connections[channel]:
                 try:
                     await connection.send_json(message)
-                except:
+                except Exception:
                     disconnected.add(connection)
 
             # Remove disconnected clients
@@ -49,7 +48,7 @@ manager = ConnectionManager()
 
 @router.websocket("/predictions")
 async def websocket_predictions(websocket: WebSocket):
-    """Real-time prediction updates"""
+    """Real-time prediction updates."""
     await manager.connect(websocket, "predictions")
     try:
         while True:
@@ -62,7 +61,7 @@ async def websocket_predictions(websocket: WebSocket):
 
 @router.websocket("/prices")
 async def websocket_prices(websocket: WebSocket):
-    """Real-time price updates"""
+    """Real-time price updates."""
     await manager.connect(websocket, "prices")
     try:
         while True:

mcli/ml/api/schemas.py

@@ -1,10 +1,10 @@
-"""API request/response schemas"""
+"""API request/response schemas."""
 
 from datetime import datetime
 from typing import Any, Dict, List, Optional
 from uuid import UUID
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 
 # Model schemas

mcli/ml/auth/__init__.py

@@ -1,4 +1,4 @@
-"""Authentication and authorization system"""
+"""Authentication and authorization system."""
 
 from .auth_manager import (
     AuthManager,

mcli/ml/auth/auth_manager.py

@@ -1,15 +1,13 @@
-"""Authentication manager with JWT support"""
+"""Authentication manager with JWT support."""
 
 import secrets
 from datetime import datetime, timedelta
-from typing import Any, Dict, Optional, Union
-from uuid import UUID
+from typing import Optional
 
 import bcrypt
 import jwt
 from fastapi import Depends, HTTPException, Request, status
 from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
-from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 from mcli.ml.config import settings
@@ -23,7 +21,7 @@ security = HTTPBearer()
 
 
 class AuthManager:
-    """Authentication and authorization manager"""
+    """Authentication and authorization manager."""
 
     def __init__(self):
         self.secret_key = settings.api.secret_key
@@ -32,19 +30,19 @@ class AuthManager:
         self.refresh_token_expire_days = 7
 
     def hash_password(self, password: str) -> str:
-        """Hash a password using bcrypt"""
+        """Hash a password using bcrypt."""
         salt = bcrypt.gensalt()
         hashed = bcrypt.hashpw(password.encode("utf-8"), salt)
         return hashed.decode("utf-8")
 
     def verify_password(self, plain_password: str, hashed_password: str) -> bool:
-        """Verify a password against a hash"""
+        """Verify a password against a hash."""
         return bcrypt.checkpw(plain_password.encode("utf-8"), hashed_password.encode("utf-8"))
 
     def create_access_token(
         self, user_id: str, username: str, role: str, expires_delta: Optional[timedelta] = None
     ) -> str:
-        """Create a JWT access token"""
+        """Create a JWT access token."""
         if expires_delta:
             expire = datetime.utcnow() + expires_delta
         else:
@@ -63,7 +61,7 @@ class AuthManager:
         return encoded_jwt
 
     def create_refresh_token(self, user_id: str, expires_delta: Optional[timedelta] = None) -> str:
-        """Create a refresh token"""
+        """Create a refresh token."""
         if expires_delta:
             expire = datetime.utcnow() + expires_delta
         else:
@@ -81,7 +79,7 @@ class AuthManager:
         return encoded_jwt
 
     def verify_token(self, token: str) -> Optional[TokenData]:
-        """Verify and decode a JWT token"""
+        """Verify and decode a JWT token."""
         try:
             payload = jwt.decode(token, self.secret_key, algorithms=[self.algorithm])
 
@@ -110,7 +108,7 @@ class AuthManager:
             )
 
     async def register_user(self, user_data: UserCreate, db: Session) -> User:
-        """Register a new user"""
+        """Register a new user."""
         # Check if user already exists
         existing_user = (
             db.query(User)
@@ -149,7 +147,7 @@ class AuthManager:
         return new_user
 
     async def authenticate_user(self, login_data: UserLogin, db: Session) -> Optional[User]:
-        """Authenticate a user"""
+        """Authenticate a user."""
         user = db.query(User).filter(User.username == login_data.username).first()
 
         if not user:
@@ -165,7 +163,7 @@ class AuthManager:
         return user
 
     async def login(self, login_data: UserLogin, db: Session) -> TokenResponse:
-        """Login user and return tokens"""
+        """Login user and return tokens."""
         user = await self.authenticate_user(login_data, db)
 
         if not user:
@@ -195,7 +193,7 @@ class AuthManager:
         )
 
     async def refresh_access_token(self, refresh_token: str, db: Session) -> TokenResponse:
-        """Refresh access token using refresh token"""
+        """Refresh access token using refresh token."""
         try:
             payload = jwt.decode(refresh_token, self.secret_key, algorithms=[self.algorithm])
 
@@ -238,7 +236,7 @@ class AuthManager:
         credentials: HTTPAuthorizationCredentials = Depends(security),
         db: Session = Depends(get_db),
     ) -> User:
-        """Get current authenticated user from JWT token"""
+        """Get current authenticated user from JWT token."""
         token = credentials.credentials
 
         token_data = self.verify_token(token)
@@ -256,7 +254,7 @@ class AuthManager:
         return user
 
     def require_role(self, *allowed_roles: UserRole):
-        """Decorator/dependency to require specific roles"""
+        """Decorator/dependency to require specific roles."""
 
         async def role_checker(current_user: User = Depends(self.get_current_user)) -> User:
             if current_user.role not in allowed_roles:
@@ -281,14 +279,14 @@ require_role = auth_manager.require_role
 
 
 async def get_current_active_user(current_user: User = Depends(get_current_user)) -> User:
-    """Get current active user"""
+    """Get current active user."""
     if not current_user.is_active:
         raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Inactive user")
     return current_user
 
 
 async def get_admin_user(current_user: User = Depends(get_current_user)) -> User:
-    """Get current admin user"""
+    """Get current admin user."""
     if current_user.role != UserRole.ADMIN:
         raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Admin access required")
     return current_user
@@ -298,11 +296,12 @@ import asyncio
 
 # Rate limiting
 from collections import defaultdict
-from datetime import datetime, timedelta
+
+# datetime and timedelta already imported at top
 
 
 class RateLimiter:
-    """Simple rate limiter"""
+    """Simple rate limiter."""
 
     def __init__(self, requests: int = 100, window: int = 60):
         self.requests = requests
@@ -311,7 +310,7 @@ class RateLimiter:
         self._cleanup_task = None
 
     async def check_rate_limit(self, client_id: str) -> bool:
-        """Check if client has exceeded rate limit"""
+        """Check if client has exceeded rate limit."""
         now = datetime.utcnow()
         minute_ago = now - timedelta(seconds=self.window)
 
@@ -329,7 +328,7 @@ class RateLimiter:
         return True
 
     async def cleanup(self):
-        """Periodic cleanup of old entries"""
+        """Periodic cleanup of old entries."""
         while True:
             await asyncio.sleep(300)  # Clean every 5 minutes
             now = datetime.utcnow()
@@ -349,7 +348,7 @@ rate_limiter = RateLimiter(requests=settings.api.rate_limit, window=60)
 
 
 async def check_rate_limit(request: Request):
-    """FastAPI dependency to check rate limit"""
+    """FastAPI dependency to check rate limit."""
     client_ip = request.client.host
 
     if not await rate_limiter.check_rate_limit(client_ip):

mcli/ml/auth/models.py

@@ -1,4 +1,4 @@
-"""Authentication data models"""
+"""Authentication data models."""
 
 from datetime import datetime
 from typing import List, Optional
@@ -8,7 +8,7 @@ from pydantic import BaseModel, EmailStr, Field, validator
 
 
 class UserCreate(BaseModel):
-    """User registration model"""
+    """User registration model."""
 
     username: str = Field(..., min_length=3, max_length=50, pattern="^[a-zA-Z0-9_-]+$")
     email: EmailStr
@@ -18,7 +18,7 @@ class UserCreate(BaseModel):
 
     @validator("password")
     def validate_password(cls, v):
-        """Ensure password meets security requirements"""
+        """Ensure password meets security requirements."""
         if len(v) < 8:
             raise ValueError("Password must be at least 8 characters long")
         if not any(char.isdigit() for char in v):
@@ -31,14 +31,14 @@ class UserCreate(BaseModel):
 
 
 class UserLogin(BaseModel):
-    """User login model"""
+    """User login model."""
 
     username: str
     password: str
 
 
 class UserResponse(BaseModel):
-    """User response model"""
+    """User response model."""
 
     id: UUID
     username: str
@@ -56,7 +56,7 @@ class UserResponse(BaseModel):
 
 
 class TokenResponse(BaseModel):
-    """JWT token response"""
+    """JWT token response."""
 
     access_token: str
     token_type: str = "Bearer"
@@ -66,7 +66,7 @@ class TokenResponse(BaseModel):
 
 
 class TokenData(BaseModel):
-    """JWT token payload"""
+    """JWT token payload."""
 
     sub: str  # User ID
     username: str
@@ -77,27 +77,27 @@ class TokenData(BaseModel):
 
 
 class PasswordReset(BaseModel):
-    """Password reset request"""
+    """Password reset request."""
 
     email: EmailStr
 
 
 class PasswordResetConfirm(BaseModel):
-    """Password reset confirmation"""
+    """Password reset confirmation."""
 
     token: str
     new_password: str = Field(..., min_length=8, max_length=100)
 
 
 class PasswordChange(BaseModel):
-    """Password change request"""
+    """Password change request."""
 
     current_password: str
     new_password: str = Field(..., min_length=8, max_length=100)
 
     @validator("new_password")
     def validate_password(cls, v, values):
-        """Ensure new password is different and meets requirements"""
+        """Ensure new password is different and meets requirements."""
         if "current_password" in values and v == values["current_password"]:
             raise ValueError("New password must be different from current password")
 
@@ -113,14 +113,14 @@ class PasswordChange(BaseModel):
 
 
 class APIKeyCreate(BaseModel):
-    """API key creation model"""
+    """API key creation model."""
 
     name: str = Field(..., min_length=1, max_length=100)
     expires_at: Optional[datetime] = None
 
 
 class APIKeyResponse(BaseModel):
-    """API key response"""
+    """API key response."""
 
     key: str
     name: str
@@ -130,7 +130,7 @@ class APIKeyResponse(BaseModel):
 
 
 class UserUpdate(BaseModel):
-    """User update model"""
+    """User update model."""
 
     email: Optional[EmailStr] = None
     first_name: Optional[str] = Field(None, max_length=50)
@@ -140,7 +140,7 @@ class UserUpdate(BaseModel):
 
 
 class UserPermissions(BaseModel):
-    """User permissions model"""
+    """User permissions model."""
 
     user_id: UUID
     permissions: List[str]
@@ -148,7 +148,7 @@ class UserPermissions(BaseModel):
 
 
 class SessionInfo(BaseModel):
-    """Session information"""
+    """Session information."""
 
     session_id: str
     user_id: UUID
@@ -160,7 +160,7 @@ class SessionInfo(BaseModel):
 
 
 class LoginAttempt(BaseModel):
-    """Login attempt tracking"""
+    """Login attempt tracking."""
 
     username: str
     ip_address: str