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

mcli/ml/api/routers/prediction_router.py

@@ -1,18 +1,18 @@
 """Prediction API routes"""
 
-from typing import List, Optional
 from datetime import datetime, timedelta
+from typing import List, Optional
 from uuid import UUID
 
-from fastapi import APIRouter, Depends, HTTPException, status, Query, BackgroundTasks
-from sqlalchemy.orm import Session
+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.auth import get_current_active_user
+from mcli.ml.cache import cache_set, cached
+from mcli.ml.database.models import Model, Prediction, StockData, User
 from mcli.ml.database.session import get_db
-from mcli.ml.database.models import User, Prediction, Model, StockData
-from mcli.ml.api.schemas import PredictionRequest, PredictionResponse, BatchPredictionRequest
-from mcli.ml.cache import cached, cache_set
 from mcli.ml.models import get_model_by_id
 
 router = APIRouter()
@@ -30,7 +30,7 @@ async def create_prediction(
     request: PredictionInput,
     background_tasks: BackgroundTasks,
     current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Create a new prediction"""
 
@@ -38,20 +38,20 @@ async def create_prediction(
     if request.model_id:
         model = db.query(Model).filter(Model.id == request.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")
     else:
         # Get default deployed model
-        model = db.query(Model).filter(
-            Model.status == "deployed"
-        ).order_by(Model.deployed_at.desc()).first()
+        model = (
+            db.query(Model)
+            .filter(Model.status == "deployed")
+            .order_by(Model.deployed_at.desc())
+            .first()
+        )
 
         if not model:
             raise HTTPException(
                 status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-                detail="No deployed model available"
+                detail="No deployed model available",
             )
 
     # Load model
@@ -59,6 +59,7 @@ async def create_prediction(
 
     # Make prediction
     import numpy as np
+
     features_array = np.array(list(request.features.values())).reshape(1, -1)
     predicted_return = float(ml_model.predict(features_array)[0])
 
@@ -74,7 +75,7 @@ async def create_prediction(
         target_date=datetime.utcnow() + timedelta(days=request.horizon),
         predicted_return=predicted_return,
         confidence_score=confidence_score,
-        feature_importance=request.features
+        feature_importance=request.features,
     )
 
     db.add(prediction)
@@ -95,7 +96,7 @@ async def create_prediction(
         confidence_score=prediction.confidence_score,
         target_date=prediction.target_date,
         model_id=model.id,
-        model_name=model.name
+        model_name=model.name,
     )
 
 
@@ -104,7 +105,7 @@ async def create_batch_predictions(
     request: BatchPredictionRequest,
     background_tasks: BackgroundTasks,
     current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Create predictions for multiple tickers"""
     predictions = []
@@ -114,15 +115,10 @@ async def create_batch_predictions(
             ticker=ticker_data.ticker,
             features=ticker_data.features,
             model_id=request.model_id,
-            horizon=request.horizon
+            horizon=request.horizon,
         )
 
-        pred = await create_prediction(
-            pred_input,
-            background_tasks,
-            current_user,
-            db
-        )
+        pred = await create_prediction(pred_input, background_tasks, current_user, db)
         predictions.append(pred)
 
     return predictions
@@ -137,7 +133,7 @@ async def list_predictions(
     start_date: Optional[datetime] = None,
     end_date: Optional[datetime] = None,
     current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """List user's predictions"""
     query = db.query(Prediction).filter(Prediction.user_id == current_user.id)
@@ -151,9 +147,7 @@ async def list_predictions(
     if end_date:
         query = query.filter(Prediction.prediction_date <= end_date)
 
-    predictions = query.order_by(
-        Prediction.prediction_date.desc()
-    ).offset(skip).limit(limit).all()
+    predictions = query.order_by(Prediction.prediction_date.desc()).offset(skip).limit(limit).all()
 
     return [PredictionResponse.from_orm(p) for p in predictions]
 
@@ -163,19 +157,17 @@ async def list_predictions(
 async def get_prediction(
     prediction_id: UUID,
     current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Get specific prediction details"""
-    prediction = db.query(Prediction).filter(
-        Prediction.id == prediction_id,
-        Prediction.user_id == current_user.id
-    ).first()
+    prediction = (
+        db.query(Prediction)
+        .filter(Prediction.id == prediction_id, Prediction.user_id == current_user.id)
+        .first()
+    )
 
     if not prediction:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Prediction not found"
-        )
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Prediction not found")
 
     return PredictionResponse.from_orm(prediction)
 
@@ -184,26 +176,24 @@ async def get_prediction(
 async def get_prediction_outcome(
     prediction_id: UUID,
     current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Get actual outcome of a prediction"""
-    prediction = db.query(Prediction).filter(
-        Prediction.id == prediction_id,
-        Prediction.user_id == current_user.id
-    ).first()
+    prediction = (
+        db.query(Prediction)
+        .filter(Prediction.id == prediction_id, Prediction.user_id == current_user.id)
+        .first()
+    )
 
     if not prediction:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Prediction not found"
-        )
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Prediction not found")
 
     # Check if target date has passed
     if prediction.target_date > datetime.utcnow():
         return {
             "status": "pending",
             "message": "Target date has not been reached yet",
-            "target_date": prediction.target_date
+            "target_date": prediction.target_date,
         }
 
     # Get actual return (mock for now)
@@ -219,7 +209,7 @@ async def get_prediction_outcome(
         "predicted_return": prediction.predicted_return,
         "actual_return": actual_return,
         "error": abs(prediction.predicted_return - actual_return),
-        "accuracy": 1 - abs(prediction.predicted_return - actual_return) / abs(actual_return)
+        "accuracy": 1 - abs(prediction.predicted_return - actual_return) / abs(actual_return),
     }
 
 
@@ -229,17 +219,20 @@ async def get_latest_recommendations(
     limit: int = Query(10, le=50),
     min_confidence: float = Query(0.7, ge=0, le=1),
     current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """Get latest stock recommendations"""
     # Get recent predictions with high confidence
-    predictions = db.query(Prediction).filter(
-        Prediction.confidence_score >= min_confidence,
-        Prediction.prediction_date >= datetime.utcnow() - timedelta(days=1)
-    ).order_by(
-        Prediction.confidence_score.desc(),
-        Prediction.predicted_return.desc()
-    ).limit(limit).all()
+    predictions = (
+        db.query(Prediction)
+        .filter(
+            Prediction.confidence_score >= min_confidence,
+            Prediction.prediction_date >= datetime.utcnow() - timedelta(days=1),
+        )
+        .order_by(Prediction.confidence_score.desc(), Prediction.predicted_return.desc())
+        .limit(limit)
+        .all()
+    )
 
     recommendations = []
     for pred in predictions:
@@ -247,13 +240,15 @@ async def get_latest_recommendations(
         if pred.predicted_return < -0.02:
             action = "sell"
 
-        recommendations.append({
-            "ticker": pred.ticker,
-            "action": action,
-            "predicted_return": pred.predicted_return,
-            "confidence": pred.confidence_score,
-            "target_date": pred.target_date
-        })
+        recommendations.append(
+            {
+                "ticker": pred.ticker,
+                "action": action,
+                "predicted_return": pred.predicted_return,
+                "confidence": pred.confidence_score,
+                "target_date": pred.target_date,
+            }
+        )
 
     return recommendations
 
@@ -264,4 +259,4 @@ async def update_stock_data(ticker: str, db: Session):
     stock = db.query(StockData).filter(StockData.ticker == ticker).first()
     if stock:
         stock.last_updated = datetime.utcnow()
-        db.commit()
+        db.commit()

mcli/ml/api/routers/trade_router.py

@@ -1,12 +1,16 @@
 """Trading 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("/politician/{politician_id}")
-async def get_politician_trades(politician_id: str, current_user: User = Depends(get_current_active_user)):
+async def get_politician_trades(
+    politician_id: str, current_user: User = Depends(get_current_active_user)
+):
     """Get politician trades"""
-    return {"politician_id": politician_id, "trades": []}
+    return {"politician_id": politician_id, "trades": []}

mcli/ml/api/routers/websocket_router.py

@@ -1,9 +1,10 @@
 """WebSocket API routes for real-time updates"""
 
-from fastapi import APIRouter, WebSocket, WebSocketDisconnect, Depends
-from typing import Dict, Set
-import json
 import asyncio
+import json
+from typing import Dict, Set
+
+from fastapi import APIRouter, Depends, WebSocket, WebSocketDisconnect
 
 from mcli.ml.logging import get_logger
 
@@ -67,10 +68,12 @@ async def websocket_prices(websocket: WebSocket):
         while True:
             await asyncio.sleep(1)
             # Send mock price update
-            await websocket.send_json({
-                "type": "price_update",
-                "ticker": "AAPL",
-                "price": 150.00 + (asyncio.get_event_loop().time() % 10)
-            })
+            await websocket.send_json(
+                {
+                    "type": "price_update",
+                    "ticker": "AAPL",
+                    "price": 150.00 + (asyncio.get_event_loop().time() % 10),
+                }
+            )
     except WebSocketDisconnect:
-        manager.disconnect(websocket, "prices")
+        manager.disconnect(websocket, "prices")

mcli/ml/api/schemas.py

@@ -1,10 +1,12 @@
 """API request/response schemas"""
 
 from datetime import datetime
-from typing import Optional, List, Dict, Any
+from typing import Any, Dict, List, Optional
 from uuid import UUID
+
 from pydantic import BaseModel, Field
 
+
 # Model schemas
 class ModelCreate(BaseModel):
     name: str
@@ -13,11 +15,13 @@ class ModelCreate(BaseModel):
     description: Optional[str] = None
     hyperparameters: Dict[str, Any] = {}
 
+
 class ModelUpdate(BaseModel):
     name: Optional[str] = None
     description: Optional[str] = None
     tags: Optional[List[str]] = None
 
+
 class ModelResponse(BaseModel):
     id: UUID
     name: str
@@ -30,6 +34,7 @@ class ModelResponse(BaseModel):
     class Config:
         orm_mode = True
 
+
 class ModelMetrics(BaseModel):
     model_id: UUID
     train_accuracy: Optional[float]
@@ -40,17 +45,20 @@ class ModelMetrics(BaseModel):
     test_loss: Optional[float]
     additional_metrics: Dict[str, Any]
 
+
 # Prediction schemas
 class PredictionRequest(BaseModel):
     ticker: str
     features: Dict[str, float]
     model_id: Optional[UUID] = None
 
+
 class BatchPredictionRequest(BaseModel):
     tickers: List[PredictionRequest]
     model_id: Optional[UUID] = None
     horizon: int = 1
 
+
 class PredictionResponse(BaseModel):
     id: UUID
     ticker: str
@@ -61,4 +69,4 @@ class PredictionResponse(BaseModel):
     model_name: str
 
     class Config:
-        orm_mode = True
+        orm_mode = True