mcli-framework 7.0.0__py3-none-any.whl

mcli/ml/api/routers/auth_router.py

@@ -0,0 +1,244 @@
+"""Authentication API routes"""
+
+from datetime import datetime
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException, status, Request
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from sqlalchemy.orm import Session
+
+from mcli.ml.auth import (
+    AuthManager,
+    UserCreate,
+    UserLogin,
+    TokenResponse,
+    UserResponse,
+    PasswordChange,
+    PasswordReset,
+    get_current_user,
+    get_current_active_user,
+    check_rate_limit,
+)
+from mcli.ml.database.session import get_db
+from mcli.ml.database.models import User
+
+router = APIRouter()
+auth_manager = AuthManager()
+security = HTTPBearer()
+
+
+@router.post("/register", response_model=UserResponse)
+async def register(
+    user_data: UserCreate,
+    db: Session = Depends(get_db),
+    _: bool = Depends(check_rate_limit)
+):
+    """Register a new user"""
+    try:
+        user = await auth_manager.register_user(user_data, db)
+        return UserResponse.from_orm(user)
+    except HTTPException:
+        raise
+    except Exception as 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 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)
+):
+    """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)
+):
+    """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)
+):
+    """Get current user information"""
+    return UserResponse.from_orm(current_user)
+
+
+@router.put("/me", response_model=UserResponse)
+async def update_current_user(
+    updates: dict,
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """Update current user information"""
+    # Update allowed fields
+    allowed_fields = ["first_name", "last_name", "email"]
+    for field in allowed_fields:
+        if field in updates:
+            setattr(current_user, field, updates[field])
+
+    db.commit()
+    db.refresh(current_user)
+    return UserResponse.from_orm(current_user)
+
+
+@router.post("/change-password")
+async def change_password(
+    password_data: PasswordChange,
+    current_user: User = Depends(get_current_active_user),
+    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
+    ):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Current password is incorrect"
+        )
+
+    # Update password
+    current_user.password_hash = auth_manager.hash_password(password_data.new_password)
+    db.commit()
+
+    return {"message": "Password changed successfully"}
+
+
+@router.post("/reset-password")
+async def reset_password_request(
+    reset_data: PasswordReset,
+    db: Session = Depends(get_db),
+    _: bool = Depends(check_rate_limit)
+):
+    """Request password reset"""
+    # Find user by email
+    user = db.query(User).filter(User.email == reset_data.email).first()
+
+    if not user:
+        # Don't reveal if email exists
+        return {"message": "If the email exists, a reset link has been sent"}
+
+    # In a real implementation, send email with reset token
+    # For now, just return success
+    return {"message": "If the email exists, a reset link has been sent"}
+
+
+@router.post("/verify-email/{token}")
+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"}
+
+
+@router.get("/sessions")
+async def get_user_sessions(
+    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
+    return {
+        "sessions": [
+            {
+                "id": "session-1",
+                "ip_address": "127.0.0.1",
+                "user_agent": "Mozilla/5.0",
+                "created_at": datetime.utcnow().isoformat(),
+                "last_active": datetime.utcnow().isoformat()
+            }
+        ]
+    }
+
+
+@router.delete("/sessions/{session_id}")
+async def revoke_session(
+    session_id: str,
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """Revoke a specific session"""
+    # In a real implementation, revoke the session
+    return {"message": f"Session {session_id} revoked successfully"}
+
+
+@router.post("/api-key")
+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)
+):
+    """Create a new API key"""
+    import secrets
+    from datetime import timedelta
+
+    api_key = secrets.token_urlsafe(32)
+
+    # Store API key in database (hashed)
+    # In real implementation, store this properly
+    current_user.api_key = api_key
+    current_user.api_key_created_at = datetime.utcnow()
+
+    db.commit()
+
+    return {
+        "api_key": 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
+    }
+
+
+@router.get("/api-keys")
+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 {
+        "api_keys": [
+            {
+                "id": "key-1",
+                "name": "Production API",
+                "created_at": datetime.utcnow().isoformat(),
+                "last_used": datetime.utcnow().isoformat(),
+                "expires_at": None
+            }
+        ]
+    }
+
+
+@router.delete("/api-keys/{key_id}")
+async def revoke_api_key(
+    key_id: str,
+    current_user: User = Depends(get_current_active_user),
+    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"}

mcli/ml/api/routers/backtest_router.py

@@ -0,0 +1,12 @@
+"""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"}

mcli/ml/api/routers/data_router.py

@@ -0,0 +1,12 @@
+"""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": {}}

mcli/ml/api/routers/model_router.py

@@ -0,0 +1,302 @@
+"""Model management API routes"""
+
+from typing import List, Optional
+from datetime import datetime
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, HTTPException, status, UploadFile, File, Query
+from sqlalchemy.orm import Session
+from sqlalchemy import select
+
+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.cache import cached
+from mcli.ml.tasks import train_model_task
+
+router = APIRouter()
+
+
+@router.get("/", response_model=List[ModelResponse])
+@cached(expire=300)
+async def list_models(
+    skip: int = Query(0, ge=0),
+    limit: int = Query(100, le=1000),
+    status: Optional[ModelStatus] = None,
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """List all available models"""
+    query = db.query(Model)
+
+    if status:
+        query = query.filter(Model.status == status)
+
+    models = query.offset(skip).limit(limit).all()
+    return [ModelResponse.from_orm(m) for m in models]
+
+
+@router.get("/{model_id}", response_model=ModelResponse)
+@cached(expire=60)
+async def get_model(
+    model_id: UUID,
+    current_user: User = Depends(get_current_active_user),
+    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"
+        )
+
+    return ModelResponse.from_orm(model)
+
+
+@router.post("/", response_model=ModelResponse)
+async def create_model(
+    model_data: ModelCreate,
+    current_user: User = Depends(require_role(UserRole.ANALYST, UserRole.ADMIN)),
+    db: Session = Depends(get_db)
+):
+    """Create a new model"""
+    model = Model(
+        **model_data.dict(),
+        created_by=current_user.username,
+        status=ModelStatus.TRAINING
+    )
+
+    db.add(model)
+    db.commit()
+    db.refresh(model)
+
+    # Trigger training task
+    train_model_task.delay(str(model.id))
+
+    return ModelResponse.from_orm(model)
+
+
+@router.put("/{model_id}", response_model=ModelResponse)
+async def update_model(
+    model_id: UUID,
+    updates: ModelUpdate,
+    current_user: User = Depends(require_role(UserRole.ANALYST, UserRole.ADMIN)),
+    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"
+        )
+
+    for field, value in updates.dict(exclude_unset=True).items():
+        setattr(model, field, value)
+
+    model.updated_at = datetime.utcnow()
+    db.commit()
+    db.refresh(model)
+
+    return ModelResponse.from_orm(model)
+
+
+@router.post("/{model_id}/deploy")
+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)
+):
+    """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"
+        )
+
+    if model.status != ModelStatus.TRAINED:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Model must be trained before deployment"
+        )
+
+    # Deploy model (in real implementation, this would deploy to serving infrastructure)
+    model.status = ModelStatus.DEPLOYED
+    model.deployed_at = datetime.utcnow()
+    model.deployment_endpoint = endpoint or f"https://api.mcli-ml.com/models/{model_id}/predict"
+
+    db.commit()
+
+    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)
+):
+    """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"
+        )
+
+    model.status = ModelStatus.ARCHIVED
+    db.commit()
+
+    return {"message": "Model archived successfully"}
+
+
+@router.get("/{model_id}/metrics", response_model=ModelMetrics)
+@cached(expire=60)
+async def get_model_metrics(
+    model_id: UUID,
+    current_user: User = Depends(get_current_active_user),
+    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"
+        )
+
+    return ModelMetrics(
+        model_id=model.id,
+        train_accuracy=model.train_accuracy,
+        val_accuracy=model.val_accuracy,
+        test_accuracy=model.test_accuracy,
+        train_loss=model.train_loss,
+        val_loss=model.val_loss,
+        test_loss=model.test_loss,
+        additional_metrics=model.metrics or {}
+    )
+
+
+@router.post("/{model_id}/retrain")
+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)
+):
+    """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"
+        )
+
+    # Update hyperparameters if provided
+    if hyperparameters:
+        model.hyperparameters = hyperparameters
+
+    model.status = ModelStatus.TRAINING
+    db.commit()
+
+    # Trigger retraining task
+    train_model_task.delay(str(model.id), retrain=True)
+
+    return {"message": "Model retraining started", "model_id": str(model.id)}
+
+
+@router.post("/{model_id}/upload")
+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)
+):
+    """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"
+        )
+
+    # Save file (in real implementation, save to S3 or similar)
+    file_path = f"/models/{model_id}/{file.filename}"
+
+    # Update model path
+    model.model_path = file_path
+    db.commit()
+
+    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)
+):
+    """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"
+        )
+
+    if model.status == ModelStatus.DEPLOYED:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Cannot delete deployed model. Archive it first."
+        )
+
+    db.delete(model)
+    db.commit()
+
+    return {"message": "Model deleted successfully"}
+
+
+@router.get("/{model_id}/download")
+async def download_model(
+    model_id: UUID,
+    current_user: User = Depends(get_current_active_user),
+    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"
+        )
+
+    if not model.model_path:
+        raise HTTPException(
+            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
+    }

mcli/ml/api/routers/monitoring_router.py

@@ -0,0 +1,12 @@
+"""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}

mcli/ml/api/routers/portfolio_router.py

@@ -0,0 +1,12 @@
+"""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": []}