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

mcli/ml/api/routers/admin_router.py

@@ -1,12 +1,14 @@
 """Admin API routes"""
 
 from fastapi import APIRouter, Depends
+
 from mcli.ml.auth import get_current_active_user, require_role
 from mcli.ml.database.models import User, UserRole
 
 router = APIRouter()
 
+
 @router.get("/users")
 async def list_users(current_user: User = Depends(require_role(UserRole.ADMIN))):
     """List all users"""
-    return {"users": []}
+    return {"users": []}

mcli/ml/api/routers/auth_router.py

@@ -3,24 +3,24 @@
 from datetime import datetime
 from typing import Optional
 
-from fastapi import APIRouter, Depends, HTTPException, status, Request
-from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from fastapi import APIRouter, Depends, HTTPException, Request, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
 from sqlalchemy.orm import Session
 
 from mcli.ml.auth import (
     AuthManager,
+    PasswordChange,
+    PasswordReset,
+    TokenResponse,
     UserCreate,
     UserLogin,
-    TokenResponse,
     UserResponse,
-    PasswordChange,
-    PasswordReset,
-    get_current_user,
-    get_current_active_user,
     check_rate_limit,
+    get_current_active_user,
+    get_current_user,
 )
-from mcli.ml.database.session import get_db
 from mcli.ml.database.models import User
+from mcli.ml.database.session import get_db
 
 router = APIRouter()
 auth_manager = AuthManager()
@@ -29,9 +29,7 @@ security = HTTPBearer()
 
 @router.post("/register", response_model=UserResponse)
 async def register(
-    user_data: UserCreate,
-    db: Session = Depends(get_db),
-    _: bool = Depends(check_rate_limit)
+    user_data: UserCreate, db: Session = Depends(get_db), _: bool = Depends(check_rate_limit)
 ):
     """Register a new user"""
     try:
@@ -40,44 +38,32 @@ async def register(
     except HTTPException:
         raise
     except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=str(e)
-        )
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
 
 
 @router.post("/login", response_model=TokenResponse)
 async def login(
-    login_data: UserLogin,
-    db: Session = Depends(get_db),
-    _: bool = Depends(check_rate_limit)
+    login_data: UserLogin, db: Session = Depends(get_db), _: bool = Depends(check_rate_limit)
 ):
     """Login and receive access token"""
     return await auth_manager.login(login_data, db)
 
 
 @router.post("/refresh", response_model=TokenResponse)
-async def refresh_token(
-    refresh_token: str,
-    db: Session = Depends(get_db)
-):
+async def refresh_token(refresh_token: str, db: Session = Depends(get_db)):
     """Refresh access token using refresh token"""
     return await auth_manager.refresh_access_token(refresh_token, db)
 
 
 @router.post("/logout")
-async def logout(
-    current_user: User = Depends(get_current_active_user)
-):
+async def logout(current_user: User = Depends(get_current_active_user)):
     """Logout current user"""
     # In a real implementation, you might want to blacklist the token
     return {"message": "Successfully logged out"}
 
 
 @router.get("/me", response_model=UserResponse)
-async def get_current_user_info(
-    current_user: User = Depends(get_current_active_user)
-):
+async def get_current_user_info(current_user: User = Depends(get_current_active_user)):
     """Get current user information"""
     return UserResponse.from_orm(current_user)
 
@@ -86,7 +72,7 @@ async def get_current_user_info(
 async def update_current_user(
     updates: dict,
     current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Update current user information"""
     # Update allowed fields
@@ -104,17 +90,13 @@ async def update_current_user(
 async def change_password(
     password_data: PasswordChange,
     current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Change current user's password"""
     # Verify current password
-    if not auth_manager.verify_password(
-        password_data.current_password,
-        current_user.password_hash
-    ):
+    if not auth_manager.verify_password(password_data.current_password, current_user.password_hash):
         raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Current password is incorrect"
+            status_code=status.HTTP_400_BAD_REQUEST, detail="Current password is incorrect"
         )
 
     # Update password
@@ -126,9 +108,7 @@ async def change_password(
 
 @router.post("/reset-password")
 async def reset_password_request(
-    reset_data: PasswordReset,
-    db: Session = Depends(get_db),
-    _: bool = Depends(check_rate_limit)
+    reset_data: PasswordReset, db: Session = Depends(get_db), _: bool = Depends(check_rate_limit)
 ):
     """Request password reset"""
     # Find user by email
@@ -144,10 +124,7 @@ async def reset_password_request(
 
 
 @router.post("/verify-email/{token}")
-async def verify_email(
-    token: str,
-    db: Session = Depends(get_db)
-):
+async def verify_email(token: str, db: Session = Depends(get_db)):
     """Verify email address"""
     # In a real implementation, verify the token and update user
     return {"message": "Email verified successfully"}
@@ -155,8 +132,7 @@ async def verify_email(
 
 @router.get("/sessions")
 async def get_user_sessions(
-    current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db)
+    current_user: User = Depends(get_current_active_user), db: Session = Depends(get_db)
 ):
     """Get all active sessions for current user"""
     # In a real implementation, return active sessions from database
@@ -167,7 +143,7 @@ async def get_user_sessions(
                 "ip_address": "127.0.0.1",
                 "user_agent": "Mozilla/5.0",
                 "created_at": datetime.utcnow().isoformat(),
-                "last_active": datetime.utcnow().isoformat()
+                "last_active": datetime.utcnow().isoformat(),
             }
         ]
     }
@@ -177,7 +153,7 @@ async def get_user_sessions(
 async def revoke_session(
     session_id: str,
     current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Revoke a specific session"""
     # In a real implementation, revoke the session
@@ -189,7 +165,7 @@ async def create_api_key(
     name: str,
     expires_in_days: Optional[int] = None,
     current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Create a new API key"""
     import secrets
@@ -209,15 +185,15 @@ async def create_api_key(
         "name": name,
         "created_at": datetime.utcnow().isoformat(),
         "expires_at": (
-            datetime.utcnow() + timedelta(days=expires_in_days)
-        ).isoformat() if expires_in_days else None
+            (datetime.utcnow() + timedelta(days=expires_in_days)).isoformat()
+            if expires_in_days
+            else None
+        ),
     }
 
 
 @router.get("/api-keys")
-async def list_api_keys(
-    current_user: User = Depends(get_current_active_user)
-):
+async def list_api_keys(current_user: User = Depends(get_current_active_user)):
     """List all API keys for current user"""
     # In a real implementation, return API keys from database
     return {
@@ -227,7 +203,7 @@ async def list_api_keys(
                 "name": "Production API",
                 "created_at": datetime.utcnow().isoformat(),
                 "last_used": datetime.utcnow().isoformat(),
-                "expires_at": None
+                "expires_at": None,
             }
         ]
     }
@@ -237,8 +213,8 @@ async def list_api_keys(
 async def revoke_api_key(
     key_id: str,
     current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Revoke an API key"""
     # In a real implementation, revoke the API key
-    return {"message": f"API key {key_id} revoked successfully"}
+    return {"message": f"API key {key_id} revoked successfully"}

mcli/ml/api/routers/backtest_router.py

@@ -1,12 +1,14 @@
 """Backtesting API routes"""
 
 from fastapi import APIRouter, Depends
+
 from mcli.ml.auth import get_current_active_user
 from mcli.ml.database.models import User
 
 router = APIRouter()
 
+
 @router.post("/run")
 async def run_backtest(current_user: User = Depends(get_current_active_user)):
     """Run backtest"""
-    return {"status": "started"}
+    return {"status": "started"}

mcli/ml/api/routers/data_router.py

@@ -1,12 +1,14 @@
 """Data API routes"""
 
 from fastapi import APIRouter, Depends
+
 from mcli.ml.auth import get_current_active_user
 from mcli.ml.database.models import User
 
 router = APIRouter()
 
+
 @router.get("/stocks/{ticker}")
 async def get_stock_data(ticker: str, current_user: User = Depends(get_current_active_user)):
     """Get stock data"""
-    return {"ticker": ticker, "data": {}}
+    return {"ticker": ticker, "data": {}}

mcli/ml/api/routers/model_router.py

@@ -1,18 +1,18 @@
 """Model management API routes"""
 
-from typing import List, Optional
 from datetime import datetime
+from typing import List, Optional
 from uuid import UUID
 
-from fastapi import APIRouter, Depends, HTTPException, status, UploadFile, File, Query
-from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends, File, HTTPException, Query, UploadFile, status
 from sqlalchemy import select
+from sqlalchemy.orm import Session
 
-from mcli.ml.auth import get_current_active_user, require_role, Permission
-from mcli.ml.database.session import get_db, get_async_db
-from mcli.ml.database.models import User, Model, ModelStatus, UserRole
-from mcli.ml.api.schemas import ModelCreate, ModelResponse, ModelUpdate, ModelMetrics
+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.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.tasks import train_model_task
 
 router = APIRouter()
@@ -25,7 +25,7 @@ async def list_models(
     limit: int = Query(100, le=1000),
     status: Optional[ModelStatus] = None,
     current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """List all available models"""
     query = db.query(Model)
@@ -42,16 +42,13 @@ async def list_models(
 async def get_model(
     model_id: UUID,
     current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Get specific model details"""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Model not found"
-        )
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Model not found")
 
     return ModelResponse.from_orm(model)
 
@@ -60,13 +57,11 @@ async def get_model(
 async def create_model(
     model_data: ModelCreate,
     current_user: User = Depends(require_role(UserRole.ANALYST, UserRole.ADMIN)),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Create a new model"""
     model = Model(
-        **model_data.dict(),
-        created_by=current_user.username,
-        status=ModelStatus.TRAINING
+        **model_data.dict(), created_by=current_user.username, status=ModelStatus.TRAINING
     )
 
     db.add(model)
@@ -84,16 +79,13 @@ async def update_model(
     model_id: UUID,
     updates: ModelUpdate,
     current_user: User = Depends(require_role(UserRole.ANALYST, UserRole.ADMIN)),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Update model metadata"""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Model not found"
-        )
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Model not found")
 
     for field, value in updates.dict(exclude_unset=True).items():
         setattr(model, field, value)
@@ -110,21 +102,18 @@ async def deploy_model(
     model_id: UUID,
     endpoint: Optional[str] = None,
     current_user: User = Depends(require_role(UserRole.ANALYST, UserRole.ADMIN)),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Deploy model to production"""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Model not found"
-        )
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Model not found")
 
     if model.status != ModelStatus.TRAINED:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Model must be trained before deployment"
+            detail="Model must be trained before deployment",
         )
 
     # Deploy model (in real implementation, this would deploy to serving infrastructure)
@@ -134,26 +123,20 @@ async def deploy_model(
 
     db.commit()
 
-    return {
-        "message": "Model deployed successfully",
-        "endpoint": model.deployment_endpoint
-    }
+    return {"message": "Model deployed successfully", "endpoint": model.deployment_endpoint}
 
 
 @router.post("/{model_id}/archive")
 async def archive_model(
     model_id: UUID,
     current_user: User = Depends(require_role(UserRole.ADMIN)),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Archive a model"""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Model not found"
-        )
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Model not found")
 
     model.status = ModelStatus.ARCHIVED
     db.commit()
@@ -166,16 +149,13 @@ async def archive_model(
 async def get_model_metrics(
     model_id: UUID,
     current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Get model performance metrics"""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Model not found"
-        )
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Model not found")
 
     return ModelMetrics(
         model_id=model.id,
@@ -185,7 +165,7 @@ async def get_model_metrics(
         train_loss=model.train_loss,
         val_loss=model.val_loss,
         test_loss=model.test_loss,
-        additional_metrics=model.metrics or {}
+        additional_metrics=model.metrics or {},
     )
 
 
@@ -194,16 +174,13 @@ async def retrain_model(
     model_id: UUID,
     hyperparameters: Optional[dict] = None,
     current_user: User = Depends(require_role(UserRole.ANALYST, UserRole.ADMIN)),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Retrain an existing model"""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Model not found"
-        )
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Model not found")
 
     # Update hyperparameters if provided
     if hyperparameters:
@@ -223,16 +200,13 @@ async def upload_model_artifact(
     model_id: UUID,
     file: UploadFile = File(...),
     current_user: User = Depends(require_role(UserRole.ANALYST, UserRole.ADMIN)),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Upload model artifact file"""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Model not found"
-        )
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Model not found")
 
     # Save file (in real implementation, save to S3 or similar)
     file_path = f"/models/{model_id}/{file.filename}"
@@ -241,31 +215,25 @@ async def upload_model_artifact(
     model.model_path = file_path
     db.commit()
 
-    return {
-        "message": "Model artifact uploaded successfully",
-        "path": file_path
-    }
+    return {"message": "Model artifact uploaded successfully", "path": file_path}
 
 
 @router.delete("/{model_id}")
 async def delete_model(
     model_id: UUID,
     current_user: User = Depends(require_role(UserRole.ADMIN)),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Delete a model"""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Model not found"
-        )
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Model not found")
 
     if model.status == ModelStatus.DEPLOYED:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Cannot delete deployed model. Archive it first."
+            detail="Cannot delete deployed model. Archive it first.",
         )
 
     db.delete(model)
@@ -278,25 +246,18 @@ async def delete_model(
 async def download_model(
     model_id: UUID,
     current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Download model artifact"""
     model = db.query(Model).filter(Model.id == model_id).first()
 
     if not model:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Model not found"
-        )
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Model not found")
 
     if not model.model_path:
         raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Model artifact not available"
+            status_code=status.HTTP_404_NOT_FOUND, detail="Model artifact not available"
         )
 
     # In real implementation, return file from storage
-    return {
-        "download_url": f"https://storage.mcli-ml.com{model.model_path}",
-        "expires_in": 3600
-    }
+    return {"download_url": f"https://storage.mcli-ml.com{model.model_path}", "expires_in": 3600}

mcli/ml/api/routers/monitoring_router.py

@@ -1,12 +1,14 @@
 """Monitoring API routes"""
 
 from fastapi import APIRouter, Depends
+
 from mcli.ml.auth import get_current_active_user
 from mcli.ml.database.models import User
 
 router = APIRouter()
 
+
 @router.get("/drift")
 async def get_drift_status(current_user: User = Depends(get_current_active_user)):
     """Get drift monitoring status"""
-    return {"drift_detected": False}
+    return {"drift_detected": False}

mcli/ml/api/routers/portfolio_router.py

@@ -1,12 +1,14 @@
 """Portfolio management API routes"""
 
 from fastapi import APIRouter, Depends
+
 from mcli.ml.auth import get_current_active_user
 from mcli.ml.database.models import User
 
 router = APIRouter()
 
+
 @router.get("/")
 async def list_portfolios(current_user: User = Depends(get_current_active_user)):
     """List user portfolios"""
-    return {"portfolios": []}
+    return {"portfolios": []}