mcli-framework 7.6.0__py3-none-any.whl → 7.6.1__py3-none-any.whl

mcli/ml/trading/trading_service.py

@@ -7,15 +7,29 @@ from typing import Dict, List, Optional, Tuple, Union
 from uuid import UUID
 
 import pandas as pd
-from sqlalchemy.orm import Session
 from sqlalchemy import and_, desc, func
+from sqlalchemy.orm import Session
 
 from mcli.ml.trading.alpaca_client import AlpacaTradingClient, create_trading_client
 from mcli.ml.trading.models import (
-    TradingAccount, Portfolio, Position, TradingOrder, PortfolioPerformanceSnapshot,
-    TradingSignal, OrderStatus, OrderType, OrderSide, PositionSide, PortfolioType,
-    TradingAccountCreate, PortfolioCreate, OrderCreate, PortfolioResponse,
-    PositionResponse, OrderResponse, TradingSignalResponse
+    OrderCreate,
+    OrderResponse,
+    OrderSide,
+    OrderStatus,
+    OrderType,
+    Portfolio,
+    PortfolioCreate,
+    PortfolioPerformanceSnapshot,
+    PortfolioResponse,
+    PortfolioType,
+    Position,
+    PositionResponse,
+    PositionSide,
+    TradingAccount,
+    TradingAccountCreate,
+    TradingOrder,
+    TradingSignal,
+    TradingSignalResponse,
 )
 
 logger = logging.getLogger(__name__)
@@ -23,11 +37,13 @@ logger = logging.getLogger(__name__)
 
 class TradingService:
     """Service for managing trading operations"""
-    
+
     def __init__(self, db_session: Session):
         self.db = db_session
-    
-    def create_trading_account(self, user_id: UUID, account_data: TradingAccountCreate) -> TradingAccount:
+
+    def create_trading_account(
+        self, user_id: UUID, account_data: TradingAccountCreate
+    ) -> TradingAccount:
         """Create a new trading account"""
         try:
             account = TradingAccount(
@@ -41,26 +57,27 @@ class TradingService:
                 max_position_size=account_data.max_position_size,
                 max_portfolio_risk=account_data.max_portfolio_risk,
             )
-            
+
             self.db.add(account)
             self.db.commit()
             self.db.refresh(account)
-            
+
             logger.info(f"Created trading account {account.id} for user {user_id}")
             return account
-            
+
         except Exception as e:
             self.db.rollback()
             logger.error(f"Failed to create trading account: {e}")
             raise
-    
+
     def get_trading_account(self, account_id: UUID) -> Optional[TradingAccount]:
         """Get trading account by ID"""
-        return self.db.query(TradingAccount).filter(
-            TradingAccount.id == account_id,
-            TradingAccount.is_active == True
-        ).first()
-    
+        return (
+            self.db.query(TradingAccount)
+            .filter(TradingAccount.id == account_id, TradingAccount.is_active == True)
+            .first()
+        )
+
     def create_portfolio(self, account_id: UUID, portfolio_data: PortfolioCreate) -> Portfolio:
         """Create a new portfolio"""
         try:
@@ -72,86 +89,89 @@ class TradingService:
                 current_value=Decimal(str(portfolio_data.initial_capital)),
                 cash_balance=Decimal(str(portfolio_data.initial_capital)),
             )
-            
+
             self.db.add(portfolio)
             self.db.commit()
             self.db.refresh(portfolio)
-            
+
             logger.info(f"Created portfolio {portfolio.id} for account {account_id}")
             return portfolio
-            
+
         except Exception as e:
             self.db.rollback()
             logger.error(f"Failed to create portfolio: {e}")
             raise
-    
+
     def get_portfolio(self, portfolio_id: UUID) -> Optional[Portfolio]:
         """Get portfolio by ID"""
-        return self.db.query(Portfolio).filter(
-            Portfolio.id == portfolio_id,
-            Portfolio.is_active == True
-        ).first()
-    
+        return (
+            self.db.query(Portfolio)
+            .filter(Portfolio.id == portfolio_id, Portfolio.is_active == True)
+            .first()
+        )
+
     def get_user_portfolios(self, user_id: UUID) -> List[Portfolio]:
         """Get all portfolios for a user"""
-        return self.db.query(Portfolio).join(TradingAccount).filter(
-            TradingAccount.user_id == user_id,
-            Portfolio.is_active == True
-        ).all()
-    
+        return (
+            self.db.query(Portfolio)
+            .join(TradingAccount)
+            .filter(TradingAccount.user_id == user_id, Portfolio.is_active == True)
+            .all()
+        )
+
     def create_alpaca_client(self, account: TradingAccount) -> AlpacaTradingClient:
         """Create Alpaca client for trading account"""
         if not account.alpaca_api_key or not account.alpaca_secret_key:
             raise ValueError("Alpaca credentials not configured for this account")
-        
+
         return create_trading_client(
             api_key=account.alpaca_api_key,
             secret_key=account.alpaca_secret_key,
-            paper_trading=account.paper_trading
+            paper_trading=account.paper_trading,
         )
-    
+
     def sync_portfolio_with_alpaca(self, portfolio: Portfolio) -> bool:
         """Sync portfolio data with Alpaca"""
         try:
             account = self.get_trading_account(portfolio.trading_account_id)
             if not account:
                 return False
-            
+
             alpaca_client = self.create_alpaca_client(account)
             alpaca_portfolio = alpaca_client.get_portfolio()
-            
+
             # Update portfolio values
             portfolio.current_value = Decimal(str(alpaca_portfolio.portfolio_value))
             portfolio.cash_balance = Decimal(str(alpaca_portfolio.cash))
             portfolio.unrealized_pl = Decimal(str(alpaca_portfolio.unrealized_pl))
             portfolio.realized_pl = Decimal(str(alpaca_portfolio.realized_pl))
-            
+
             # Calculate returns
             if portfolio.initial_capital > 0:
                 total_return = portfolio.current_value - portfolio.initial_capital
                 portfolio.total_return = float(total_return)
                 portfolio.total_return_pct = float(total_return / portfolio.initial_capital * 100)
-            
+
             # Update positions
             self._sync_positions(portfolio, alpaca_portfolio.positions)
-            
+
             # Create performance snapshot
             self._create_performance_snapshot(portfolio)
-            
+
             self.db.commit()
             logger.info(f"Synced portfolio {portfolio.id} with Alpaca")
             return True
-            
+
         except Exception as e:
             self.db.rollback()
             logger.error(f"Failed to sync portfolio with Alpaca: {e}")
             return False
-    
+
     def _sync_positions(self, portfolio: Portfolio, alpaca_positions: List):
         """Sync positions with Alpaca data"""
         # Clear existing positions
         self.db.query(Position).filter(Position.portfolio_id == portfolio.id).delete()
-        
+
         # Add new positions
         for alpaca_pos in alpaca_positions:
             position = Position(
@@ -169,7 +189,7 @@ class TradingService:
                 weight=float(alpaca_pos.market_value / portfolio.current_value),
             )
             self.db.add(position)
-    
+
     def _create_performance_snapshot(self, portfolio: Portfolio):
         """Create daily performance snapshot"""
         snapshot = PortfolioPerformanceSnapshot(
@@ -187,7 +207,7 @@ class TradingService:
             positions_data=self._get_positions_data(portfolio.id),
         )
         self.db.add(snapshot)
-    
+
     def _get_positions_data(self, portfolio_id: UUID) -> Dict:
         """Get positions data for snapshot"""
         positions = self.db.query(Position).filter(Position.portfolio_id == portfolio_id).all()
@@ -203,33 +223,36 @@ class TradingService:
             }
             for pos in positions
         }
-    
-    def place_order(self, portfolio_id: UUID, order_data: OrderCreate, check_risk: bool = True) -> TradingOrder:
+
+    def place_order(
+        self, portfolio_id: UUID, order_data: OrderCreate, check_risk: bool = True
+    ) -> TradingOrder:
         """Place a trading order"""
         try:
             portfolio = self.get_portfolio(portfolio_id)
             if not portfolio:
                 raise ValueError("Portfolio not found")
-            
+
             account = self.get_trading_account(portfolio.trading_account_id)
             if not account:
                 raise ValueError("Trading account not found")
-            
+
             # Check risk limits if enabled
             if check_risk:
                 from mcli.ml.trading.risk_management import RiskManager
+
                 risk_manager = RiskManager(self)
-                
+
                 order_dict = {
                     "symbol": order_data.symbol,
                     "quantity": order_data.quantity,
                     "side": order_data.side.value,
                 }
-                
+
                 risk_ok, warnings = risk_manager.check_risk_limits(portfolio_id, order_dict)
                 if not risk_ok:
                     raise ValueError(f"Order violates risk limits: {'; '.join(warnings)}")
-            
+
             # Create order record
             order = TradingOrder(
                 trading_account_id=account.id,
@@ -238,26 +261,28 @@ class TradingService:
                 side=order_data.side,
                 order_type=order_data.order_type,
                 quantity=order_data.quantity,
-                limit_price=Decimal(str(order_data.limit_price)) if order_data.limit_price else None,
+                limit_price=(
+                    Decimal(str(order_data.limit_price)) if order_data.limit_price else None
+                ),
                 stop_price=Decimal(str(order_data.stop_price)) if order_data.stop_price else None,
                 remaining_quantity=order_data.quantity,
                 time_in_force=order_data.time_in_force,
                 extended_hours=order_data.extended_hours,
             )
-            
+
             self.db.add(order)
             self.db.flush()  # Get the ID
-            
+
             # Place order with Alpaca if account has credentials
             if account.alpaca_api_key and account.alpaca_secret_key:
                 alpaca_client = self.create_alpaca_client(account)
-                
+
                 if order_data.order_type == OrderType.MARKET:
                     alpaca_order = alpaca_client.place_market_order(
                         symbol=order_data.symbol,
                         quantity=order_data.quantity,
                         side=order_data.side.value,
-                        time_in_force=order_data.time_in_force
+                        time_in_force=order_data.time_in_force,
                     )
                 elif order_data.order_type == OrderType.LIMIT:
                     alpaca_order = alpaca_client.place_limit_order(
@@ -265,26 +290,26 @@ class TradingService:
                         quantity=order_data.quantity,
                         side=order_data.side.value,
                         limit_price=order_data.limit_price,
-                        time_in_force=order_data.time_in_force
+                        time_in_force=order_data.time_in_force,
                     )
                 else:
                     raise ValueError(f"Unsupported order type: {order_data.order_type}")
-                
+
                 order.alpaca_order_id = alpaca_order.id
                 order.status = OrderStatus.SUBMITTED
                 order.submitted_at = datetime.utcnow()
-            
+
             self.db.commit()
             self.db.refresh(order)
-            
+
             logger.info(f"Placed order {order.id} for portfolio {portfolio_id}")
             return order
-            
+
         except Exception as e:
             self.db.rollback()
             logger.error(f"Failed to place order: {e}")
             raise
-    
+
     def get_portfolio_positions(self, portfolio_id: UUID) -> List[PositionResponse]:
         """Get all positions for a portfolio"""
         positions = self.db.query(Position).filter(Position.portfolio_id == portfolio_id).all()
@@ -308,13 +333,15 @@ class TradingService:
             )
             for pos in positions
         ]
-    
-    def get_portfolio_orders(self, portfolio_id: UUID, status: Optional[OrderStatus] = None) -> List[OrderResponse]:
+
+    def get_portfolio_orders(
+        self, portfolio_id: UUID, status: Optional[OrderStatus] = None
+    ) -> List[OrderResponse]:
         """Get orders for a portfolio"""
         query = self.db.query(TradingOrder).filter(TradingOrder.portfolio_id == portfolio_id)
         if status:
             query = query.filter(TradingOrder.status == status)
-        
+
         orders = query.order_by(desc(TradingOrder.created_at)).all()
         return [
             OrderResponse(
@@ -325,7 +352,9 @@ class TradingService:
                 quantity=order.quantity,
                 limit_price=float(order.limit_price) if order.limit_price else None,
                 stop_price=float(order.stop_price) if order.stop_price else None,
-                average_fill_price=float(order.average_fill_price) if order.average_fill_price else None,
+                average_fill_price=(
+                    float(order.average_fill_price) if order.average_fill_price else None
+                ),
                 status=order.status,
                 filled_quantity=order.filled_quantity,
                 remaining_quantity=order.remaining_quantity,
@@ -339,34 +368,41 @@ class TradingService:
             )
             for order in orders
         ]
-    
+
     def get_portfolio_performance(self, portfolio_id: UUID, days: int = 30) -> pd.DataFrame:
         """Get portfolio performance history"""
         end_date = datetime.utcnow()
         start_date = end_date - timedelta(days=days)
-        
-        snapshots = self.db.query(PortfolioPerformanceSnapshot).filter(
-            PortfolioPerformanceSnapshot.portfolio_id == portfolio_id,
-            PortfolioPerformanceSnapshot.snapshot_date >= start_date
-        ).order_by(PortfolioPerformanceSnapshot.snapshot_date).all()
-        
+
+        snapshots = (
+            self.db.query(PortfolioPerformanceSnapshot)
+            .filter(
+                PortfolioPerformanceSnapshot.portfolio_id == portfolio_id,
+                PortfolioPerformanceSnapshot.snapshot_date >= start_date,
+            )
+            .order_by(PortfolioPerformanceSnapshot.snapshot_date)
+            .all()
+        )
+
         data = []
         for snapshot in snapshots:
-            data.append({
-                "date": snapshot.snapshot_date,
-                "portfolio_value": float(snapshot.portfolio_value),
-                "cash_balance": float(snapshot.cash_balance),
-                "daily_return": float(snapshot.daily_return),
-                "daily_return_pct": snapshot.daily_return_pct,
-                "total_return": float(snapshot.total_return),
-                "total_return_pct": snapshot.total_return_pct,
-                "volatility": snapshot.volatility,
-                "sharpe_ratio": snapshot.sharpe_ratio,
-                "max_drawdown": snapshot.max_drawdown,
-            })
-        
+            data.append(
+                {
+                    "date": snapshot.snapshot_date,
+                    "portfolio_value": float(snapshot.portfolio_value),
+                    "cash_balance": float(snapshot.cash_balance),
+                    "daily_return": float(snapshot.daily_return),
+                    "daily_return_pct": snapshot.daily_return_pct,
+                    "total_return": float(snapshot.total_return),
+                    "total_return_pct": snapshot.total_return_pct,
+                    "volatility": snapshot.volatility,
+                    "sharpe_ratio": snapshot.sharpe_ratio,
+                    "max_drawdown": snapshot.max_drawdown,
+                }
+            )
+
         return pd.DataFrame(data)
-    
+
     def create_trading_signal(
         self,
         portfolio_id: UUID,
@@ -379,12 +415,14 @@ class TradingService:
         stop_loss: Optional[float] = None,
         take_profit: Optional[float] = None,
         position_size: Optional[float] = None,
-        expires_hours: int = 24
+        expires_hours: int = 24,
     ) -> TradingSignal:
         """Create a trading signal"""
         try:
-            expires_at = datetime.utcnow() + timedelta(hours=expires_hours) if expires_hours > 0 else None
-            
+            expires_at = (
+                datetime.utcnow() + timedelta(hours=expires_hours) if expires_hours > 0 else None
+            )
+
             signal = TradingSignal(
                 portfolio_id=portfolio_id,
                 symbol=symbol,
@@ -398,27 +436,32 @@ class TradingService:
                 position_size=position_size,
                 expires_at=expires_at,
             )
-            
+
             self.db.add(signal)
             self.db.commit()
             self.db.refresh(signal)
-            
+
             logger.info(f"Created trading signal {signal.id} for {symbol}")
             return signal
-            
+
         except Exception as e:
             self.db.rollback()
             logger.error(f"Failed to create trading signal: {e}")
             raise
-    
+
     def get_active_signals(self, portfolio_id: UUID) -> List[TradingSignalResponse]:
         """Get active trading signals for a portfolio"""
-        signals = self.db.query(TradingSignal).filter(
-            TradingSignal.portfolio_id == portfolio_id,
-            TradingSignal.is_active == True,
-            TradingSignal.expires_at > datetime.utcnow()
-        ).order_by(desc(TradingSignal.created_at)).all()
-        
+        signals = (
+            self.db.query(TradingSignal)
+            .filter(
+                TradingSignal.portfolio_id == portfolio_id,
+                TradingSignal.is_active == True,
+                TradingSignal.expires_at > datetime.utcnow(),
+            )
+            .order_by(desc(TradingSignal.created_at))
+            .all()
+        )
+
         return [
             TradingSignalResponse(
                 id=signal.id,
@@ -438,16 +481,16 @@ class TradingService:
             )
             for signal in signals
         ]
-    
+
     def calculate_portfolio_metrics(self, portfolio_id: UUID) -> Dict:
         """Calculate portfolio performance metrics"""
         portfolio = self.get_portfolio(portfolio_id)
         if not portfolio:
             return {}
-        
+
         # Get performance history
         performance_df = self.get_portfolio_performance(portfolio_id, days=90)
-        
+
         if performance_df.empty:
             return {
                 "total_return": 0.0,
@@ -458,16 +501,18 @@ class TradingService:
                 "current_value": float(portfolio.current_value),
                 "cash_balance": float(portfolio.cash_balance),
             }
-        
+
         # Calculate metrics
         returns = performance_df["daily_return_pct"].dropna()
-        
+
         total_return = performance_df["total_return"].iloc[-1] if not performance_df.empty else 0
-        total_return_pct = performance_df["total_return_pct"].iloc[-1] if not performance_df.empty else 0
-        volatility = returns.std() * (252 ** 0.5) if len(returns) > 1 else 0  # Annualized
+        total_return_pct = (
+            performance_df["total_return_pct"].iloc[-1] if not performance_df.empty else 0
+        )
+        volatility = returns.std() * (252**0.5) if len(returns) > 1 else 0  # Annualized
         sharpe_ratio = (returns.mean() * 252) / volatility if volatility > 0 else 0  # Annualized
         max_drawdown = performance_df["max_drawdown"].max() if not performance_df.empty else 0
-        
+
         return {
             "total_return": total_return,
             "total_return_pct": total_return_pct,
@@ -477,4 +522,4 @@ class TradingService:
             "current_value": float(portfolio.current_value),
             "cash_balance": float(portfolio.cash_balance),
             "num_positions": len(self.get_portfolio_positions(portfolio_id)),
-        }
+        }

mcli/ml/training/train_model.py

@@ -452,9 +452,7 @@ def save_model(
             "model_architecture": {
                 "input_size": model.network[0].in_features,
                 "hidden_layers": [
-                    layer.out_features
-                    for layer in model.network
-                    if isinstance(layer, nn.Linear)
+                    layer.out_features for layer in model.network if isinstance(layer, nn.Linear)
                 ][:-1],
             },
             "scaler_mean": scaler.mean_.tolist(),