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

mcli/ml/trading/migrations.py

@@ -1,10 +1,12 @@
 """Database migrations for trading functionality"""
 
 import logging
+
 from sqlalchemy import create_engine, text
 from sqlalchemy.orm import sessionmaker
-from mcli.ml.trading.models import Base
+
 from mcli.ml.config.settings import get_settings
+from mcli.ml.trading.models import Base
 
 logger = logging.getLogger(__name__)
 
@@ -15,13 +17,13 @@ def create_trading_tables():
         # Get database URL from settings
         settings = get_settings()
         engine = create_engine(settings.database.url)
-        
+
         # Create all tables
         Base.metadata.create_all(engine)
-        
+
         logger.info("Trading tables created successfully")
         return True
-        
+
     except Exception as e:
         logger.error(f"Failed to create trading tables: {e}")
         return False
@@ -33,13 +35,13 @@ def drop_trading_tables():
         # Get database URL from settings
         settings = get_settings()
         engine = create_engine(settings.database.url)
-        
+
         # Drop all tables
         Base.metadata.drop_all(engine)
-        
+
         logger.info("Trading tables dropped successfully")
         return True
-        
+
     except Exception as e:
         logger.error(f"Failed to drop trading tables: {e}")
         return False
@@ -53,14 +55,14 @@ def migrate_trading_data():
         engine = create_engine(settings.database.url)
         Session = sessionmaker(bind=engine)
         session = Session()
-        
+
         # Check if we need to migrate existing portfolio data
         # This would depend on your existing schema
-        
+
         session.close()
         logger.info("Trading data migration completed")
         return True
-        
+
     except Exception as e:
         logger.error(f"Failed to migrate trading data: {e}")
         return False
@@ -72,78 +74,112 @@ def verify_trading_schema():
         # Get database URL from settings
         settings = get_settings()
         engine = create_engine(settings.database.url)
-        
+
         # Check if tables exist
         with engine.connect() as conn:
             # Check for trading_accounts table
             if "sqlite" in settings.database.url:
                 # SQLite syntax
-                result = conn.execute(text("""
+                result = conn.execute(
+                    text(
+                        """
                     SELECT name FROM sqlite_master 
                     WHERE type='table' AND name='trading_accounts';
-                """))
+                """
+                    )
+                )
                 accounts_exists = result.fetchone() is not None
-                
-                result = conn.execute(text("""
+
+                result = conn.execute(
+                    text(
+                        """
                     SELECT name FROM sqlite_master 
                     WHERE type='table' AND name='portfolios';
-                """))
+                """
+                    )
+                )
                 portfolios_exists = result.fetchone() is not None
-                
-                result = conn.execute(text("""
+
+                result = conn.execute(
+                    text(
+                        """
                     SELECT name FROM sqlite_master 
                     WHERE type='table' AND name='positions';
-                """))
+                """
+                    )
+                )
                 positions_exists = result.fetchone() is not None
-                
-                result = conn.execute(text("""
+
+                result = conn.execute(
+                    text(
+                        """
                     SELECT name FROM sqlite_master 
                     WHERE type='table' AND name='trading_orders';
-                """))
+                """
+                    )
+                )
                 orders_exists = result.fetchone() is not None
             else:
                 # PostgreSQL syntax
-                result = conn.execute(text("""
+                result = conn.execute(
+                    text(
+                        """
                     SELECT EXISTS (
                         SELECT FROM information_schema.tables 
                         WHERE table_name = 'trading_accounts'
                     );
-                """))
+                """
+                    )
+                )
                 accounts_exists = result.scalar()
-                
-                result = conn.execute(text("""
+
+                result = conn.execute(
+                    text(
+                        """
                     SELECT EXISTS (
                         SELECT FROM information_schema.tables 
                         WHERE table_name = 'portfolios'
                     );
-                """))
+                """
+                    )
+                )
                 portfolios_exists = result.scalar()
-                
-                result = conn.execute(text("""
+
+                result = conn.execute(
+                    text(
+                        """
                     SELECT EXISTS (
                         SELECT FROM information_schema.tables 
                         WHERE table_name = 'positions'
                     );
-                """))
+                """
+                    )
+                )
                 positions_exists = result.scalar()
-                
-                result = conn.execute(text("""
+
+                result = conn.execute(
+                    text(
+                        """
                     SELECT EXISTS (
                         SELECT FROM information_schema.tables 
                         WHERE table_name = 'trading_orders'
                     );
-                """))
+                """
+                    )
+                )
                 orders_exists = result.scalar()
-        
-        all_tables_exist = all([accounts_exists, portfolios_exists, positions_exists, orders_exists])
-        
+
+        all_tables_exist = all(
+            [accounts_exists, portfolios_exists, positions_exists, orders_exists]
+        )
+
         if all_tables_exist:
             logger.info("Trading schema verification successful")
         else:
             logger.warning("Some trading tables are missing")
-            
+
         return all_tables_exist
-        
+
     except Exception as e:
         logger.error(f"Failed to verify trading schema: {e}")
         return False
@@ -156,9 +192,9 @@ if __name__ == "__main__":
         print("✅ Trading tables created successfully")
     else:
         print("❌ Failed to create trading tables")
-    
+
     print("Verifying schema...")
     if verify_trading_schema():
         print("✅ Trading schema verified successfully")
     else:
-        print("❌ Trading schema verification failed")
+        print("❌ Trading schema verification failed")

mcli/ml/trading/models.py

@@ -7,20 +7,20 @@ from enum import Enum
 from typing import Any, Dict, List, Optional, Union
 from uuid import UUID, uuid4
 
-from sqlalchemy import (
-    Boolean, Column, DateTime, Enum as SQLEnum, Float, ForeignKey, 
-    Integer, String, Text, JSON, Numeric, Index
-)
+from pydantic import BaseModel, Field
+from sqlalchemy import JSON, Boolean, Column, DateTime
+from sqlalchemy import Enum as SQLEnum
+from sqlalchemy import Float, ForeignKey, Index, Integer, Numeric, String, Text
 from sqlalchemy.dialects.postgresql import UUID as PostgresUUID
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import relationship
-from pydantic import BaseModel, Field
 
 Base = declarative_base()
 
 
 class OrderStatus(Enum):
     """Order status enumeration"""
+
     PENDING = "pending"
     SUBMITTED = "submitted"
     FILLED = "filled"
@@ -32,6 +32,7 @@ class OrderStatus(Enum):
 
 class OrderType(Enum):
     """Order type enumeration"""
+
     MARKET = "market"
     LIMIT = "limit"
     STOP = "stop"
@@ -41,18 +42,21 @@ class OrderType(Enum):
 
 class OrderSide(Enum):
     """Order side enumeration"""
+
     BUY = "buy"
     SELL = "sell"
 
 
 class PositionSide(Enum):
     """Position side enumeration"""
+
     LONG = "long"
     SHORT = "short"
 
 
 class PortfolioType(Enum):
     """Portfolio type enumeration"""
+
     TEST = "test"
     LIVE = "live"
     PAPER = "paper"
@@ -60,6 +64,7 @@ class PortfolioType(Enum):
 
 class RiskLevel(Enum):
     """Risk level enumeration"""
+
     CONSERVATIVE = "conservative"
     MODERATE = "moderate"
     AGGRESSIVE = "aggressive"
@@ -68,29 +73,30 @@ class RiskLevel(Enum):
 # Database Models
 class TradingAccount(Base):
     """Trading account information"""
+
     __tablename__ = "trading_accounts"
-    
+
     id = Column(PostgresUUID(as_uuid=True), primary_key=True, default=uuid4)
     user_id = Column(PostgresUUID(as_uuid=True), nullable=False)  # Remove foreign key for now
     account_name = Column(String(100), nullable=False)
     account_type = Column(SQLEnum(PortfolioType), nullable=False, default=PortfolioType.TEST)
-    
+
     # Alpaca credentials (encrypted)
     alpaca_api_key = Column(String(255), nullable=True)
     alpaca_secret_key = Column(String(255), nullable=True)
     alpaca_base_url = Column(String(255), nullable=True)
-    
+
     # Account settings
     paper_trading = Column(Boolean, default=True)
     risk_level = Column(SQLEnum(RiskLevel), default=RiskLevel.MODERATE)
     max_position_size = Column(Float, default=0.1)  # Max 10% per position
     max_portfolio_risk = Column(Float, default=0.2)  # Max 20% portfolio risk
-    
+
     # Metadata
     created_at = Column(DateTime, default=datetime.utcnow)
     updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
     is_active = Column(Boolean, default=True)
-    
+
     # Relationships
     portfolios = relationship("Portfolio", back_populates="trading_account")
     orders = relationship("TradingOrder", back_populates="trading_account")
@@ -98,18 +104,21 @@ class TradingAccount(Base):
 
 class Portfolio(Base):
     """Portfolio information"""
+
     __tablename__ = "portfolios"
-    
+
     id = Column(PostgresUUID(as_uuid=True), primary_key=True, default=uuid4)
-    trading_account_id = Column(PostgresUUID(as_uuid=True), ForeignKey("trading_accounts.id"), nullable=False)
+    trading_account_id = Column(
+        PostgresUUID(as_uuid=True), ForeignKey("trading_accounts.id"), nullable=False
+    )
     name = Column(String(100), nullable=False)
     description = Column(Text, nullable=True)
-    
+
     # Portfolio settings
     initial_capital = Column(Numeric(15, 2), nullable=False, default=100000.00)
     current_value = Column(Numeric(15, 2), nullable=False, default=100000.00)
     cash_balance = Column(Numeric(15, 2), nullable=False, default=100000.00)
-    
+
     # Performance metrics
     total_return = Column(Float, default=0.0)
     total_return_pct = Column(Float, default=0.0)
@@ -120,17 +129,17 @@ class Portfolio(Base):
     max_drawdown = Column(Float, default=0.0)
     max_drawdown_duration = Column(Integer, default=0)
     volatility = Column(Float, default=0.0)
-    
+
     # Risk metrics
     var_95 = Column(Float, default=0.0)  # Value at Risk 95%
     cvar_95 = Column(Float, default=0.0)  # Conditional Value at Risk 95%
     beta = Column(Float, default=1.0)
-    
+
     # Status
     is_active = Column(Boolean, default=True)
     created_at = Column(DateTime, default=datetime.utcnow)
     updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
-    
+
     # Relationships
     trading_account = relationship("TradingAccount", back_populates="portfolios")
     positions = relationship("Position", back_populates="portfolio")
@@ -140,174 +149,177 @@ class Portfolio(Base):
 
 class Position(Base):
     """Individual position in a portfolio"""
+
     __tablename__ = "positions"
-    
+
     id = Column(PostgresUUID(as_uuid=True), primary_key=True, default=uuid4)
     portfolio_id = Column(PostgresUUID(as_uuid=True), ForeignKey("portfolios.id"), nullable=False)
     symbol = Column(String(10), nullable=False, index=True)
-    
+
     # Position details
     quantity = Column(Integer, nullable=False)
     side = Column(SQLEnum(PositionSide), nullable=False)
     average_price = Column(Numeric(10, 4), nullable=False)
     current_price = Column(Numeric(10, 4), nullable=False)
-    
+
     # Financial metrics
     market_value = Column(Numeric(15, 2), nullable=False)
     cost_basis = Column(Numeric(15, 2), nullable=False)
     unrealized_pnl = Column(Numeric(15, 2), nullable=False, default=0.0)
     unrealized_pnl_pct = Column(Float, nullable=False, default=0.0)
     realized_pnl = Column(Numeric(15, 2), nullable=False, default=0.0)
-    
+
     # Position sizing
     position_size_pct = Column(Float, nullable=False, default=0.0)  # % of portfolio
     weight = Column(Float, nullable=False, default=0.0)  # Portfolio weight
-    
+
     # Metadata
     created_at = Column(DateTime, default=datetime.utcnow)
     updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
-    
+
     # Relationships
     portfolio = relationship("Portfolio", back_populates="positions")
     trades = relationship("TradingOrder", back_populates="position")
-    
+
     # Indexes
-    __table_args__ = (
-        Index('idx_position_portfolio_symbol', 'portfolio_id', 'symbol'),
-    )
+    __table_args__ = (Index("idx_position_portfolio_symbol", "portfolio_id", "symbol"),)
 
 
 class TradingOrder(Base):
     """Trading order information"""
+
     __tablename__ = "trading_orders"
-    
+
     id = Column(PostgresUUID(as_uuid=True), primary_key=True, default=uuid4)
-    trading_account_id = Column(PostgresUUID(as_uuid=True), ForeignKey("trading_accounts.id"), nullable=False)
+    trading_account_id = Column(
+        PostgresUUID(as_uuid=True), ForeignKey("trading_accounts.id"), nullable=False
+    )
     portfolio_id = Column(PostgresUUID(as_uuid=True), ForeignKey("portfolios.id"), nullable=False)
     position_id = Column(PostgresUUID(as_uuid=True), ForeignKey("positions.id"), nullable=True)
-    
+
     # Order details
     symbol = Column(String(10), nullable=False, index=True)
     side = Column(SQLEnum(OrderSide), nullable=False)
     order_type = Column(SQLEnum(OrderType), nullable=False)
     quantity = Column(Integer, nullable=False)
-    
+
     # Pricing
     limit_price = Column(Numeric(10, 4), nullable=True)
     stop_price = Column(Numeric(10, 4), nullable=True)
     average_fill_price = Column(Numeric(10, 4), nullable=True)
-    
+
     # Status and execution
     status = Column(SQLEnum(OrderStatus), nullable=False, default=OrderStatus.PENDING)
     filled_quantity = Column(Integer, nullable=False, default=0)
     remaining_quantity = Column(Integer, nullable=False)
-    
+
     # Timestamps
     created_at = Column(DateTime, default=datetime.utcnow)
     submitted_at = Column(DateTime, nullable=True)
     filled_at = Column(DateTime, nullable=True)
     cancelled_at = Column(DateTime, nullable=True)
-    
+
     # Additional info
     time_in_force = Column(String(20), default="day")
     extended_hours = Column(Boolean, default=False)
     client_order_id = Column(String(100), nullable=True)
     alpaca_order_id = Column(String(100), nullable=True, index=True)
-    
+
     # Relationships
     trading_account = relationship("TradingAccount", back_populates="orders")
     portfolio = relationship("Portfolio", back_populates="orders")
     position = relationship("Position", back_populates="trades")
-    
+
     # Indexes
     __table_args__ = (
-        Index('idx_order_portfolio_status', 'portfolio_id', 'status'),
-        Index('idx_order_symbol_status', 'symbol', 'status'),
+        Index("idx_order_portfolio_status", "portfolio_id", "status"),
+        Index("idx_order_symbol_status", "symbol", "status"),
     )
 
 
 class PortfolioPerformanceSnapshot(Base):
     """Daily portfolio performance snapshots"""
+
     __tablename__ = "portfolio_performance_snapshots"
-    
+
     id = Column(PostgresUUID(as_uuid=True), primary_key=True, default=uuid4)
     portfolio_id = Column(PostgresUUID(as_uuid=True), ForeignKey("portfolios.id"), nullable=False)
-    
+
     # Snapshot data
     snapshot_date = Column(DateTime, nullable=False, index=True)
     portfolio_value = Column(Numeric(15, 2), nullable=False)
     cash_balance = Column(Numeric(15, 2), nullable=False)
-    
+
     # Daily performance
     daily_return = Column(Numeric(15, 2), nullable=False, default=0.0)
     daily_return_pct = Column(Float, nullable=False, default=0.0)
-    
+
     # Cumulative performance
     total_return = Column(Numeric(15, 2), nullable=False, default=0.0)
     total_return_pct = Column(Float, nullable=False, default=0.0)
-    
+
     # Risk metrics
     volatility = Column(Float, nullable=False, default=0.0)
     sharpe_ratio = Column(Float, nullable=False, default=0.0)
     max_drawdown = Column(Float, nullable=False, default=0.0)
-    
+
     # Position data (JSON)
     positions_data = Column(JSON, nullable=True)
-    
+
     # Metadata
     created_at = Column(DateTime, default=datetime.utcnow)
-    
+
     # Relationships
     portfolio = relationship("Portfolio", back_populates="performance_snapshots")
-    
+
     # Indexes
-    __table_args__ = (
-        Index('idx_snapshot_portfolio_date', 'portfolio_id', 'snapshot_date'),
-    )
+    __table_args__ = (Index("idx_snapshot_portfolio_date", "portfolio_id", "snapshot_date"),)
 
 
 class TradingSignal(Base):
     """Trading signals generated by ML models"""
+
     __tablename__ = "trading_signals"
-    
+
     id = Column(PostgresUUID(as_uuid=True), primary_key=True, default=uuid4)
     portfolio_id = Column(PostgresUUID(as_uuid=True), ForeignKey("portfolios.id"), nullable=False)
-    
+
     # Signal details
     symbol = Column(String(10), nullable=False, index=True)
     signal_type = Column(String(20), nullable=False)  # "buy", "sell", "hold"
     confidence = Column(Float, nullable=False)
     strength = Column(Float, nullable=False)  # Signal strength 0-1
-    
+
     # ML model info
     model_id = Column(String(100), nullable=True)
     model_version = Column(String(50), nullable=True)
     prediction_id = Column(PostgresUUID(as_uuid=True), nullable=True)
-    
+
     # Signal parameters
     target_price = Column(Numeric(10, 4), nullable=True)
     stop_loss = Column(Numeric(10, 4), nullable=True)
     take_profit = Column(Numeric(10, 4), nullable=True)
     position_size = Column(Float, nullable=True)  # Suggested position size as % of portfolio
-    
+
     # Metadata
     created_at = Column(DateTime, default=datetime.utcnow)
     expires_at = Column(DateTime, nullable=True)
     is_active = Column(Boolean, default=True)
-    
+
     # Relationships
     portfolio = relationship("Portfolio")
-    
+
     # Indexes
     __table_args__ = (
-        Index('idx_signal_portfolio_symbol', 'portfolio_id', 'symbol'),
-        Index('idx_signal_created_active', 'created_at', 'is_active'),
+        Index("idx_signal_portfolio_symbol", "portfolio_id", "symbol"),
+        Index("idx_signal_created_active", "created_at", "is_active"),
     )
 
 
 # Pydantic Models for API
 class TradingAccountCreate(BaseModel):
     """Create trading account request"""
+
     account_name: str = Field(..., min_length=1, max_length=100)
     account_type: PortfolioType = Field(default=PortfolioType.TEST)
     alpaca_api_key: Optional[str] = None
@@ -320,6 +332,7 @@ class TradingAccountCreate(BaseModel):
 
 class PortfolioCreate(BaseModel):
     """Create portfolio request"""
+
     name: str = Field(..., min_length=1, max_length=100)
     description: Optional[str] = None
     initial_capital: float = Field(default=100000.0, gt=0)
@@ -327,6 +340,7 @@ class PortfolioCreate(BaseModel):
 
 class OrderCreate(BaseModel):
     """Create order request"""
+
     symbol: str = Field(..., min_length=1, max_length=10)
     side: OrderSide
     order_type: OrderType
@@ -339,6 +353,7 @@ class OrderCreate(BaseModel):
 
 class PositionResponse(BaseModel):
     """Position response model"""
+
     id: UUID
     symbol: str
     quantity: int
@@ -358,6 +373,7 @@ class PositionResponse(BaseModel):
 
 class OrderResponse(BaseModel):
     """Order response model"""
+
     id: UUID
     symbol: str
     side: OrderSide
@@ -380,6 +396,7 @@ class OrderResponse(BaseModel):
 
 class PortfolioResponse(BaseModel):
     """Portfolio response model"""
+
     id: UUID
     name: str
     description: Optional[str]
@@ -402,6 +419,7 @@ class PortfolioResponse(BaseModel):
 
 class TradingSignalResponse(BaseModel):
     """Trading signal response model"""
+
     id: UUID
     symbol: str
     signal_type: str
@@ -415,4 +433,4 @@ class TradingSignalResponse(BaseModel):
     position_size: Optional[float]
     created_at: datetime
     expires_at: Optional[datetime]
-    is_active: bool
+    is_active: bool