Sync with backend: 5-level dynamic leverage system, enhanced signal analysis

.gitignore

@@ -1,6 +1,9 @@
 node_modules
-venv
-__pycache__
+venv/
+__pycache__/
 *.pyc
+*.pkl
+models/
+data/
+# Keep environment variables out of version control
 .env
-*.db

README_HF.md

@@ -0,0 +1,85 @@
+---
+title: AlgoQuant Backend API
+emoji: 🚀
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+license: mit
+---
+
+# AlgoQuant Backend API 🚀
+
+Production-grade FastAPI backend for algorithmic cryptocurrency trading with AI-powered strategies.
+
+## Features
+
+- 🤖 **HMM-SVR Walk-Forward Strategy** - Zero lookahead bias backtesting
+- 📊 **Pairs Trading** - Statistical arbitrage (ETH/BTC)
+- 💼 **Paper Trading** - Simulated trading with $10,000 starting capital
+- 🔒 **Secure Auth** - JWT authentication with bcrypt
+- ⚡ **Real-Time Data** - Binance Testnet + Yahoo Finance
+
+## API Documentation
+
+Once deployed, access the interactive API docs at:
+- **Swagger UI:** `https://your-space-name.hf.space/docs`
+- **ReDoc:** `https://your-space-name.hf.space/redoc`
+
+## Endpoints
+
+### Authentication
+- `POST /signup` - Create new user account
+- `POST /login` - Get JWT access token
+
+### Trading
+- `POST /backtest` - Run strategy backtesting
+- `POST /start-live-trading` - Start simulated trading session
+- `POST /stop-live-trading/{session_id}` - Stop trading session
+- `GET /portfolio` - Get user portfolio balance
+- `GET /trading-sessions` - List all trading sessions
+- `GET /trades` - Get trade history
+
+### Data
+- `GET /price/{ticker}` - Get current price for ticker
+- `GET /dashboard` - Get dashboard metrics
+
+## Environment Variables
+
+Required for production:
+```bash
+DATABASE_URL=postgresql://user:password@host:5432/dbname
+SECRET_KEY=your-secret-key-here
+```
+
+## Tech Stack
+
+- **FastAPI** - Modern async web framework
+- **PostgreSQL** - Production database
+- **SQLModel** - SQL ORM with type safety
+- **scikit-learn** - Machine learning
+- **hmmlearn** - Hidden Markov Models
+- **yfinance** - Free market data
+
+## Local Development
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Train HMM model
+python train_hmm_model.py
+
+# Run server
+uvicorn main:app --reload --port 8000
+```
+
+## License
+
+MIT License - See LICENSE for details
+
+---
+
+**Built with 🧠 for quantitative traders**
+
+*Part of the AlgoQuant AI-Powered Trading Platform*

live_trading.py

@@ -1,900 +0,0 @@
-"""
-Live Trading Module for Binance Testnet
-Handles real trading operations using paper money on Binance Testnet Vision
-"""
-import os
-import time
-import threading
-from datetime import datetime, timedelta
-from typing import Optional, Dict, List
-from binance.client import Client
-from binance.enums import *
-import pandas as pd
-import numpy as np
-import yfinance as yf
-from hmmlearn.hmm import GaussianHMM
-from dotenv import load_dotenv
-from sqlmodel import Session, select
-from database import engine
-from models import Trade, TradingSession
-
-load_dotenv()
-
-# Binance Testnet Configuration
-TESTNET_API_KEY = os.getenv("BINANCE_API_KEY", "")
-TESTNET_API_SECRET = os.getenv("BINANCE_SECRET_KEY", "")
-
-# Storage for active trading sessions (in-memory for real-time tracking)
-active_sessions: Dict[str, "BaseTradingSessionRunner"] = {}
-
-# Portfolio cache to prevent API rate limits
-_portfolio_cache = {'data': None, 'timestamp': None}
-_CACHE_DURATION = 30  # seconds
-
-
-def get_testnet_client():
-    """Create Binance testnet client with timestamp sync"""
-    try:
-        # Create client without timestamp initially to sync time
-        client = Client(TESTNET_API_KEY, TESTNET_API_SECRET, testnet=True)
-        
-        # Sync time with Binance server to avoid timestamp issues
-        try:
-            server_time = client.get_server_time()
-            time_offset = server_time['serverTime'] - int(time.time() * 1000)
-            # Adjust for any offset (subtract 1 second for safety)
-            client.timestamp_offset = time_offset - 1000
-        except Exception as e:
-            print(f"[Warning] Could not sync time with Binance: {e}")
-            # Set a small negative offset as fallback
-            client.timestamp_offset = -1000
-        
-        return client
-    except Exception as e:
-        print(f"[Error] Failed to create Binance client: {e}")
-        # Return basic client as fallback
-        client = Client(TESTNET_API_KEY, TESTNET_API_SECRET, testnet=True)
-        client.timestamp_offset = -1000
-        return client
-
-
-def get_account_balance():
-    """Get current testnet account balance"""
-    try:
-        client = get_testnet_client()
-        account = client.get_account()
-        balances = []
-        for balance in account['balances']:
-            free = float(balance['free'])
-            locked = float(balance['locked'])
-            if free > 0 or locked > 0:
-                balances.append({
-                    'asset': balance['asset'],
-                    'free': free,
-                    'locked': locked,
-                    'total': free + locked
-                })
-        return balances
-    except Exception as e:
-        return {"error": str(e)}
-
-
-def get_portfolio_value():
-    """Get total portfolio value in USDT (with caching and SAFE batch price fetch)"""
-    global _portfolio_cache
-    
-    # Check cache first
-    if _portfolio_cache['data'] is not None and _portfolio_cache['timestamp'] is not None:
-        elapsed = (datetime.now() - _portfolio_cache['timestamp']).total_seconds()
-        if elapsed < _CACHE_DURATION:
-            return _portfolio_cache['data']
-    
-    try:
-        client = get_testnet_client()
-        account = client.get_account()
-        
-        # Assets that are stablecoins or don't have USDT pairs on testnet
-        skip_assets = {'USDT', 'BUSD', 'USDC', 'DAI', 'TUSD', 'PAX', 'TRY', 'ZAR', 'UAH', 'BRL', 'EUR', 'GBP', 'AUD', 'NGN', 'RUB', 'UAH', 'BIDR', 'IDRT', 'VAI'}
-        
-        # First pass: identify symbols to fetch (ONLY what user actually holds)
-        symbols_to_fetch = []
-        for balance in account['balances']:
-            free = float(balance.get('free', 0))
-            locked = float(balance.get('locked', 0))
-            total = free + locked
-            if total > 0.001:
-                asset = balance.get('asset', 'UNKNOWN')
-                if asset not in skip_assets and asset != 'USDT':
-                    symbols_to_fetch.append(f"{asset}USDT")
-        
-        # Batch fetch ONLY needed prices (API weight: 2 per symbol - very safe!)
-        price_map = {}
-        for symbol in symbols_to_fetch:
-            try:
-                ticker = client.get_symbol_ticker(symbol=symbol)
-                price_map[symbol] = float(ticker['price'])
-            except Exception as e:
-                # Silently skip invalid symbols
-                pass
-        
-        total_usdt = 0.0
-        holdings = []
-        
-        # Second pass: calculate values using pre-fetched prices
-        for balance in account['balances']:
-            try:
-                free = float(balance.get('free', 0))
-                locked = float(balance.get('locked', 0))
-                total = free + locked
-                
-                if total > 0.001:  # Ignore dust
-                    asset = balance.get('asset', 'UNKNOWN')
-                    
-                    if asset == 'USDT':
-                        value_usdt = total
-                        if value_usdt > 0.01:
-                            holdings.append({
-                                'asset': asset,
-                                'quantity': total,
-                                'value_usdt': value_usdt
-                            })
-                            total_usdt += value_usdt
-                    elif asset not in skip_assets:
-                        # Use pre-fetched price from batch call
-                        trading_pair = f"{asset}USDT"
-                        price = price_map.get(trading_pair, 0.0)
-                        
-                        if price > 0:
-                            value_usdt = total * price
-                            if value_usdt > 0.01:
-                                holdings.append({
-                                    'asset': asset,
-                                    'quantity': total,
-                                    'value_usdt': value_usdt
-                                })
-                                total_usdt += value_usdt
-            except Exception as balance_error:
-                print(f"[Portfolio] Error processing balance: {balance_error}")
-                continue
-        
-        result = {
-            'total_value_usdt': round(total_usdt, 2),
-            'holdings': holdings
-        }
-        
-        # Update cache
-        _portfolio_cache['data'] = result
-        _portfolio_cache['timestamp'] = datetime.now()
-        
-        return result
-    except Exception as e:
-        print(f"[Portfolio] Error getting portfolio value: {e}")
-        import traceback
-        traceback.print_exc()
-        default = {"error": str(e)}
-        # Cache the error result too
-        _portfolio_cache['data'] = default
-        _portfolio_cache['timestamp'] = datetime.now()
-        return default
-
-
-def get_recent_trades_from_db(user_email: str, limit: int = 20) -> List[dict]:
-    """Get recent trades from database - only bot trades (excludes manual trades)"""
-    try:
-        with Session(engine) as session:
-            # Filter out manual trades by excluding session_ids starting with "manual_"
-            statement = select(Trade).where(
-                Trade.user_email == user_email,
-                ~Trade.session_id.startswith("manual_")
-            ).order_by(Trade.executed_at.desc()).limit(limit)
-            trades = session.exec(statement).all()
-            
-            result = []
-            for t in trades:
-                trade_dict = {
-                    'symbol': t.symbol,
-                    'side': t.side,
-                    'price': t.price,
-                    'quantity': t.quantity,
-                    'total': t.total,
-                    'pnl': t.pnl,
-                    'time': t.executed_at.isoformat()
-                }
-                
-                # Calculate pnl_percent for SELL trades
-                if t.side == "SELL" and t.pnl is not None and t.total > 0:
-                    # PnL percent = (pnl / cost_basis) * 100
-                    cost_basis = t.total - t.pnl
-                    if cost_basis > 0:
-                        trade_dict['pnl_percent'] = (t.pnl / cost_basis) * 100
-                
-                result.append(trade_dict)
-            
-            return result
-    except Exception as e:
-        print(f"Error getting bot trades: {e}")
-        return []
-
-
-def get_recent_trades(symbol: Optional[str] = None, limit: int = 20):
-    """Get recent trades from the testnet account"""
-    try:
-        client = get_testnet_client()
-        if symbol:
-            trades = client.get_my_trades(symbol=symbol, limit=limit)
-        else:
-            all_trades = []
-            symbols = ['BTCUSDT', 'ETHUSDT', 'BNBUSDT', 'SOLUSDT']
-            for sym in symbols:
-                try:
-                    trades = client.get_my_trades(symbol=sym, limit=5)
-                    all_trades.extend(trades)
-                except:
-                    pass
-            trades = sorted(all_trades, key=lambda x: x['time'], reverse=True)[:limit]
-        
-        formatted_trades = []
-        for trade in trades:
-            formatted_trades.append({
-                'symbol': trade['symbol'],
-                'side': 'BUY' if trade['isBuyer'] else 'SELL',
-                'price': float(trade['price']),
-                'quantity': float(trade['qty']),
-                'total': float(trade['quoteQty']),
-                'commission': float(trade['commission']),
-                'time': datetime.fromtimestamp(trade['time'] / 1000).isoformat()
-            })
-        
-        return formatted_trades
-    except Exception as e:
-        return {"error": str(e)}
-
-
-def get_current_price(symbol: str):
-    """Get current price for a symbol"""
-    try:
-        client = get_testnet_client()
-        ticker = client.get_symbol_ticker(symbol=symbol)
-        return float(ticker['price'])
-    except Exception as e:
-        return None
-
-
-def get_symbol_filters(symbol: str):
-    """Get trading filters for a symbol (LOT_SIZE, MIN_NOTIONAL, etc.)"""
-    try:
-        client = get_testnet_client()
-        info = client.get_symbol_info(symbol)
-        
-        filters = {}
-        for f in info.get('filters', []):
-            if f['filterType'] == 'LOT_SIZE':
-                filters['min_qty'] = float(f['minQty'])
-                filters['max_qty'] = float(f['maxQty'])
-                filters['step_size'] = float(f['stepSize'])
-            elif f['filterType'] == 'MIN_NOTIONAL':
-                filters['min_notional'] = float(f.get('minNotional', f.get('notional', 0)))
-        
-        return filters
-    except Exception as e:
-        print(f"[Filters] Could not get filters for {symbol}: {e}")
-        return None
-
-def adjust_quantity(symbol: str, quantity: float):
-    """Adjust quantity to meet exchange requirements"""
-    filters = get_symbol_filters(symbol)
-    
-    if not filters:
-        # Fallback to default precision
-        if 'BTC' in symbol and symbol.endswith('BTC'):
-            return round(quantity, 3)
-        elif 'USDT' in symbol:
-            return round(quantity, 3)
-        return quantity
-    
-    min_qty = filters.get('min_qty', 0)
-    step_size = filters.get('step_size', 0.00001)
-    
-    # Adjust to step size
-    adjusted = round(quantity / step_size) * step_size
-    
-    # Ensure minimum quantity
-    if adjusted < min_qty:
-        adjusted = min_qty
-    
-    # Round to appropriate precision
-    precision = len(str(step_size).rstrip('0').split('.')[-1]) if '.' in str(step_size) else 0
-    adjusted = round(adjusted, precision)
-    
-    print(f"[Quantity] Original: {quantity}, Adjusted: {adjusted} (min: {min_qty}, step: {step_size})")
-    return adjusted
-
-def place_market_order(symbol: str, side: str, quantity: float):
-    """Place a market order on testnet"""
-    try:
-        client = get_testnet_client()
-        
-        # Adjust quantity to meet exchange requirements
-        quantity = adjust_quantity(symbol, quantity)
-        
-        print(f"[Order] Placing {side} order: {symbol} qty={quantity}")
-        
-        order = client.create_order(
-            symbol=symbol,
-            side=SIDE_BUY if side.upper() == 'BUY' else SIDE_SELL,
-            type=ORDER_TYPE_MARKET,
-            quantity=quantity
-        )
-        print(f"[Order] Success: Order ID {order.get('orderId', 'N/A')}")
-        return order
-    except Exception as e:
-        error_msg = str(e)
-        print(f"[Order] Failed: {error_msg}")
-        return {"error": error_msg}
-
-
-def save_trade_to_db(session_id: str, user_email: str, symbol: str, 
-                      side: str, price: float, quantity: float, 
-                      pnl: Optional[float] = None, order_id: Optional[str] = None):
-    """Save a trade to the database"""
-    try:
-        with Session(engine) as db_session:
-            trade = Trade(
-                session_id=session_id,
-                user_email=user_email,
-                symbol=symbol,
-                side=side,
-                price=price,
-                quantity=quantity,
-                total=price * quantity,
-                pnl=pnl,
-                order_id=order_id,
-                executed_at=datetime.now()
-            )
-            db_session.add(trade)
-            db_session.commit()
-    except Exception as e:
-        print(f"Error saving trade: {e}")
-
-
-def save_session_to_db(session_id: str, user_email: str, strategy: str,
-                        symbol: str, trade_amount: float, duration_minutes: int):
-    """Save a trading session to the database"""
-    try:
-        with Session(engine) as db_session:
-            trading_session = TradingSession(
-                session_id=session_id,
-                user_email=user_email,
-                strategy=strategy,
-                symbol=symbol,
-                trade_amount=trade_amount,
-                duration_minutes=duration_minutes,
-                start_time=datetime.now(),
-                is_running=True
-            )
-            db_session.add(trading_session)
-            db_session.commit()
-    except Exception as e:
-        print(f"Error saving session: {e}")
-
-
-def update_session_in_db(session_id: str, is_running: bool, 
-                          total_pnl: float, trades_count: int):
-    """Update a trading session in the database"""
-    try:
-        with Session(engine) as db_session:
-            statement = select(TradingSession).where(
-                TradingSession.session_id == session_id
-            )
-            trading_session = db_session.exec(statement).first()
-            if trading_session:
-                trading_session.is_running = is_running
-                trading_session.total_pnl = total_pnl
-                trading_session.trades_count = trades_count
-                if not is_running:
-                    trading_session.end_time = datetime.now()
-                db_session.add(trading_session)
-                db_session.commit()
-    except Exception as e:
-        print(f"Error updating session: {e}")
-
-
-def get_user_sessions_from_db(user_email: str) -> List[dict]:
-    """Get all sessions for a user from database"""
-    try:
-        with Session(engine) as db_session:
-            statement = select(TradingSession).where(
-                TradingSession.user_email == user_email
-            ).order_by(TradingSession.start_time.desc()).limit(20)
-            sessions = db_session.exec(statement).all()
-            
-            result = []
-            for s in sessions:
-                # Check if session is in active_sessions for real-time data
-                if s.session_id in active_sessions:
-                    runner = active_sessions[s.session_id]
-                    result.append(runner.get_status())
-                else:
-                    # Calculate elapsed time from database
-                    elapsed = (datetime.now() - s.start_time).total_seconds() / 60
-                    remaining = max(0, s.duration_minutes - elapsed)
-                    
-                    # Auto-mark as stopped if time is up and not in active runners
-                    if s.is_running and remaining <= 0:
-                        s.is_running = False
-                        s.end_time = datetime.now()
-                        db_session.add(s)
-                        db_session.commit()
-                    
-                    result.append({
-                        'session_id': s.session_id,
-                        'strategy': s.strategy,
-                        'symbol': s.symbol,
-                        'trade_amount': s.trade_amount,
-                        'is_running': s.is_running,
-                        'position': 'FLAT',
-                        'trades_count': s.trades_count,
-                        'pnl': s.total_pnl,
-                        'elapsed_minutes': round(elapsed, 1),
-                        'remaining_minutes': round(remaining, 1),
-                        'trades': []
-                    })
-            return result
-    except Exception as e:
-        print(f"Error getting sessions: {e}")
-        return []
-
-
-class BaseTradingSessionRunner:
-    """Base class for managing a live trading session."""
-    
-    def __init__(self, session_id: str, user_email: str, strategy: str, 
-                 symbols: List[str], trade_amount: float, duration_minutes: int):
-        self.session_id = session_id
-        self.user_email = user_email
-        self.strategy = strategy
-        self.symbols = symbols
-        self.trade_amount = trade_amount
-        self.duration_minutes = duration_minutes
-        self.start_time = datetime.now()
-        self.is_running = False
-        self.trades: List[dict] = []
-        self.pnl = 0.0
-        self.client = get_testnet_client()
-        self._thread: Optional[threading.Thread] = None
-
-    def start(self):
-        self.is_running = True
-        save_session_to_db(
-            self.session_id, self.user_email, self.strategy,
-            ",".join(self.symbols), self.trade_amount, self.duration_minutes
-        )
-        self._thread = threading.Thread(target=self._run_strategy, daemon=True)
-        self._thread.start()
-        
-    def stop(self):
-        self.is_running = False
-        self._on_stop()
-        update_session_in_db(
-            self.session_id, False, self.pnl, len(self.trades)
-        )
-            
-    def _run_strategy(self):
-        raise NotImplementedError
-
-    def _on_stop(self):
-        pass
-
-    def get_status(self) -> dict:
-        raise NotImplementedError
-
-class MediumFrequencySessionRunner(BaseTradingSessionRunner):
-    """
-    Medium-Frequency HMM-SVR Strategy Runner.
-    
-    Uses pre-trained HMM-SVR models (loaded from disk) to make trading decisions
-    every 3 hours based on:
-    - Regime detection (Safe/Normal/Crash)
-    - Volatility prediction
-    - EMA crossover signals
-    - Dynamic position sizing (0x, 1x, or 3x)
-    """
-    
-    # Trading interval: 3 hours in seconds
-    TRADE_INTERVAL_SECONDS = 3 * 60 * 60  # 3 hours
-    
-    def __init__(self, session_id: str, user_email: str, symbol: str, 
-                 trade_amount: float, duration_minutes: int,
-                 short_window: int = 12, long_window: int = 26):
-        super().__init__(session_id, user_email, "hmm_svr", [symbol], trade_amount, duration_minutes)
-        self.symbol = symbol
-        self.short_window = short_window
-        self.long_window = long_window
-        
-        # Position tracking
-        self.current_position_qty = 0.0  # Actual quantity held
-        self.target_position_size = 0.0  # Target multiplier (0, 1, or 3)
-        self.entry_price = 0.0
-        self.last_signal_info = {}
-        
-        # Ensure model is loaded
-        from model_manager import load_model, is_model_trained
-        if not is_model_trained(symbol):
-            raise Exception(f"No trained model found for {symbol}. Train it first using /api/models/train/{symbol}")
-        
-        model_data = load_model(symbol)
-        if model_data is None:
-            raise Exception(f"Failed to load model for {symbol}")
-        
-        print(f"[MediumFreq] Initialized for {symbol} with model trained on {model_data.get('train_days', 0)} days")
-
-    def _on_stop(self):
-        """Close any open position when session stops."""
-        if self.current_position_qty > 0:
-            print(f"[MediumFreq] Closing position on stop: {self.current_position_qty} {self.symbol}")
-            self._adjust_position(0)
-
-    def _run_strategy(self):
-        """
-        Main strategy loop - runs every 3 hours.
-        """
-        end_time = self.start_time.timestamp() + (self.duration_minutes * 60)
-        
-        # Run immediately on start
-        self._execute_trading_cycle()
-        
-        while self.is_running and time.time() < end_time:
-            try:
-                # Sleep in smaller intervals to allow for graceful shutdown
-                sleep_remaining = self.TRADE_INTERVAL_SECONDS
-                while sleep_remaining > 0 and self.is_running and time.time() < end_time:
-                    sleep_chunk = min(60, sleep_remaining)  # Sleep 1 minute at a time
-                    time.sleep(sleep_chunk)
-                    sleep_remaining -= sleep_chunk
-                
-                if self.is_running and time.time() < end_time:
-                    self._execute_trading_cycle()
-                    
-            except Exception as e:
-                print(f"[MediumFreq] Strategy error: {e}")
-                import traceback
-                traceback.print_exc()
-                time.sleep(60)  # Wait before retrying
-        
-        self.is_running = False
-        self._on_stop()
-        update_session_in_db(self.session_id, False, self.pnl, len(self.trades))
-        print(f"[MediumFreq] Session ended. Total PnL: ${self.pnl:.2f}")
-
-    def _execute_trading_cycle(self):
-        """
-        Execute one trading cycle:
-        1. Fetch recent data
-        2. Generate signal using pre-trained model
-        3. Calculate target position
-        4. Adjust position if needed
-        """
-        print(f"\n{'='*60}")
-        print(f"[MediumFreq] Trading cycle at {datetime.now().isoformat()}")
-        print(f"{'='*60}")
-        
-        try:
-            # 1. Fetch recent daily data (400 days for proper feature calculation)
-            recent_data = self._fetch_recent_data(days=400)
-            if recent_data is None or len(recent_data) < 100:
-                print("[MediumFreq] Insufficient data, skipping cycle")
-                return
-            
-            # 2. Generate signal using model_manager
-            from model_manager import calculate_signal_and_position
-            signal_result = calculate_signal_and_position(
-                symbol=self.symbol,
-                recent_data=recent_data,
-                short_window=self.short_window,
-                long_window=self.long_window
-            )
-            
-            if signal_result is None or 'error' in signal_result:
-                print(f"[MediumFreq] Signal error: {signal_result}")
-                return
-            
-            self.last_signal_info = signal_result
-            
-            # 3. Calculate target position in USDT terms
-            target_multiplier = signal_result['target_position']  # 0, 1, or 3
-            ema_signal = signal_result['ema_signal']
-            current_price = signal_result['close_price']
-            
-            print(f"[MediumFreq] Signal Analysis:")
-            print(f"  - Regime: {signal_result['regime_label']} (state {signal_result['regime']})")
-            print(f"  - Predicted Vol: {signal_result['predicted_vol']:.6f}")
-            print(f"  - Risk Ratio: {signal_result['risk_ratio']:.2f}")
-            print(f"  - EMA Signal: {'BULLISH' if ema_signal == 1 else 'BEARISH'}")
-            print(f"  - Position Multiplier: {target_multiplier}x")
-            print(f"  - Reasoning: {signal_result['reasoning']}")
-            
-            # 4. Calculate target quantity in asset terms
-            target_usdt_value = self.trade_amount * target_multiplier
-            target_quantity = target_usdt_value / current_price if current_price > 0 else 0
-            
-            # 5. Get current position from exchange
-            current_qty = self._get_current_position()
-            
-            print(f"\n[MediumFreq] Position Status:")
-            print(f"  - Current Position: {current_qty:.8f} {self.symbol.replace('USDT', '')}")
-            print(f"  - Target Position: {target_quantity:.8f} ({target_multiplier}x = ${target_usdt_value:.2f})")
-            
-            # 6. Calculate and execute trade delta
-            trade_delta = target_quantity - current_qty
-            
-            if abs(trade_delta * current_price) > 10:  # Minimum $10 trade
-                self._adjust_position(target_quantity)
-            else:
-                print(f"[MediumFreq] Trade delta too small (${abs(trade_delta * current_price):.2f}), no action")
-            
-            self.target_position_size = target_multiplier
-            
-        except Exception as e:
-            print(f"[MediumFreq] Error in trading cycle: {e}")
-            import traceback
-            traceback.print_exc()
-
-    def _fetch_recent_data(self, days: int = 400) -> Optional[pd.DataFrame]:
-        """
-        Fetch recent daily data from Binance for signal generation.
-        """
-        try:
-            # Use public client (no API keys needed for klines)
-            client = Client()
-            
-            klines = client.get_historical_klines(
-                symbol=self.symbol,
-                interval=Client.KLINE_INTERVAL_1DAY,
-                limit=days
-            )
-            
-            if not klines or len(klines) < 100:
-                print(f"[MediumFreq] Insufficient klines returned: {len(klines) if klines else 0}")
-                return None
-            
-            df = pd.DataFrame(klines, columns=[
-                'timestamp', 'Open', 'High', 'Low', 'Close', 'Volume',
-                'close_time', 'quote_volume', 'trades', 'taker_buy_base',
-                'taker_buy_quote', 'ignore'
-            ])
-            
-            df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
-            df.set_index('timestamp', inplace=True)
-            df['Close'] = df['Close'].astype(float)
-            df['Open'] = df['Open'].astype(float)
-            df['High'] = df['High'].astype(float)
-            df['Low'] = df['Low'].astype(float)
-            
-            print(f"[MediumFreq] Fetched {len(df)} days of data, latest close: ${df['Close'].iloc[-1]:.2f}")
-            return df[['Open', 'High', 'Low', 'Close', 'Volume']]
-            
-        except Exception as e:
-            print(f"[MediumFreq] Error fetching data: {e}")
-            return None
-
-    def _get_current_position(self) -> float:
-        """Get current quantity of the asset held."""
-        try:
-            account = self.client.get_account()
-            asset = self.symbol.replace('USDT', '')
-            
-            for balance in account['balances']:
-                if balance['asset'] == asset:
-                    qty = float(balance['free']) + float(balance['locked'])
-                    return qty
-            return 0.0
-        except Exception as e:
-            print(f"[MediumFreq] Error getting position: {e}")
-            return self.current_position_qty  # Fallback to tracked quantity
-
-    def _adjust_position(self, target_qty: float):
-        """
-        Adjust position to match target quantity.
-        Handles both increasing and decreasing positions.
-        """
-        current_qty = self._get_current_position()
-        delta = target_qty - current_qty
-        price = get_current_price(self.symbol)
-        
-        if price is None:
-            print(f"[MediumFreq] Cannot get price for {self.symbol}")
-            return
-        
-        if abs(delta) < 0.00001:  # Negligible difference
-            print(f"[MediumFreq] Position already at target")
-            return
-        
-        if delta > 0:
-            # Need to buy
-            side = 'BUY'
-            quantity = delta
-        else:
-            # Need to sell
-            side = 'SELL'
-            quantity = abs(delta)
-        
-        print(f"[MediumFreq] Placing {side} order: {quantity:.8f} @ ${price:.2f} (${quantity * price:.2f})")
-        
-        order = place_market_order(self.symbol, side, quantity)
-        
-        if 'error' not in order:
-            order_id = str(order.get('orderId', ''))
-            pnl = None
-            
-            # Calculate PnL for sells
-            if side == 'SELL' and self.entry_price > 0:
-                pnl = (price - self.entry_price) * quantity
-                self.pnl += pnl
-                print(f"[MediumFreq] Trade PnL: ${pnl:.2f}")
-            
-            # Update entry price tracking
-            if side == 'BUY':
-                if self.current_position_qty == 0:
-                    self.entry_price = price
-                else:
-                    # Average entry price
-                    total_cost = (self.entry_price * self.current_position_qty) + (price * quantity)
-                    self.entry_price = total_cost / (self.current_position_qty + quantity)
-            
-            self.current_position_qty = target_qty
-            
-            self.trades.append({
-                'type': side,
-                'price': price,
-                'quantity': quantity,
-                'time': datetime.now().isoformat(),
-                'pnl': pnl,
-                'order_id': order_id,
-                'target_multiplier': self.target_position_size,
-                'regime': self.last_signal_info.get('regime_label', 'Unknown')
-            })
-            
-            save_trade_to_db(
-                self.session_id, self.user_email, self.symbol,
-                side, price, quantity, pnl, order_id
-            )
-            
-            update_session_in_db(self.session_id, True, self.pnl, len(self.trades))
-            print(f"[MediumFreq] ✅ Order executed successfully")
-        else:
-            print(f"[MediumFreq] ❌ Order failed: {order['error']}")
-
-    def get_status(self) -> dict:
-        elapsed = (datetime.now() - self.start_time).total_seconds() / 60
-        remaining = max(0, self.duration_minutes - elapsed)
-        
-        # Calculate next trade time
-        time_since_start = (datetime.now() - self.start_time).total_seconds()
-        cycles_completed = int(time_since_start / self.TRADE_INTERVAL_SECONDS)
-        next_trade_in = self.TRADE_INTERVAL_SECONDS - (time_since_start % self.TRADE_INTERVAL_SECONDS)
-        
-        pos_str = "FLAT"
-        if self.current_position_qty > 0:
-            pos_str = f"LONG {self.target_position_size}x"
-        
-        return {
-            'session_id': self.session_id,
-            'strategy': 'hmm_svr',
-            'strategy_name': 'HMM-SVR Medium Frequency',
-            'symbol': self.symbol,
-            'trade_amount': self.trade_amount,
-            'is_running': self.is_running,
-            'position': pos_str,
-            'position_qty': self.current_position_qty,
-            'target_multiplier': self.target_position_size,
-            'trades_count': len(self.trades),
-            'pnl': round(self.pnl, 2),
-            'elapsed_minutes': round(elapsed, 1),
-            'remaining_minutes': round(remaining, 1),
-            'next_trade_in_minutes': round(next_trade_in / 60, 1),
-            'trade_interval_hours': 3,
-            'last_signal': self.last_signal_info,
-            'trades': self.trades[-10:]
-        }
-
-
-def start_live_trading(user_email: str, strategy: str, symbol: str, 
-                       trade_amount: float, duration_minutes: int,
-                       duration_unit: str = "minutes",
-                       short_window: int = 12, long_window: int = 26,
-                       interval: str = '5m') -> dict:
-    """Factory function to start a new live trading session."""
-    session_id = f"{user_email}_{datetime.now().strftime('%Y%m%d%H%M%S')}"
-    
-    for sid, session in active_sessions.items():
-        if session.user_email == user_email and session.is_running:
-            return {"error": "You already have an active trading session"}
-    
-    if not symbol:
-        return {"error": "Symbol is required"}
-    
-    if strategy != "hmm_svr":
-        return {"error": f"Unsupported strategy '{strategy}'. Only 'hmm_svr' is available."}
-    
-    try:
-        # Medium-frequency strategy using pre-trained models
-        session = MediumFrequencySessionRunner(
-            session_id=session_id, user_email=user_email,
-            symbol=symbol, trade_amount=trade_amount, duration_minutes=duration_minutes,
-            short_window=short_window, long_window=long_window
-        )
-    except Exception as e:
-        return {"error": f"Failed to start session: {e}"}
-
-    active_sessions[session_id] = session
-    session.start()
-    
-    return {
-        "success": True, "session_id": session_id,
-        "message": f"Trading session started with {strategy} on {symbol}"
-    }
-
-
-def stop_live_trading(session_id: str) -> dict:
-    """Stop an active trading session."""
-    if session_id in active_sessions:
-        session = active_sessions[session_id]
-        session.stop()
-        del active_sessions[session_id]
-        return {"success": True, "message": "Trading session stopped.", "final_pnl": session.pnl}
-    
-    # Fallback for sessions not in memory
-    try:
-        with Session(engine) as db_session:
-            statement = select(TradingSession).where(TradingSession.session_id == session_id, TradingSession.is_running == True)
-            trading_session = db_session.exec(statement).first()
-            if trading_session:
-                trading_session.is_running = False
-                trading_session.end_time = datetime.now()
-                db_session.add(trading_session)
-                db_session.commit()
-                return {"success": True, "message": "Trading session stopped (was not active in memory)."}
-    except Exception as e:
-        print(f"Error stopping session in DB: {e}")
-    
-    return {"error": "Session not found or already stopped"}
-
-
-def get_session_status(session_id: str) -> dict:
-    """Get status of a trading session."""
-    if session_id in active_sessions:
-        return active_sessions[session_id].get_status()
-    
-    # If not active, pull final from DB
-    try:
-        with Session(engine) as db_session:
-            statement = select(TradingSession).where(TradingSession.session_id == session_id)
-            s = db_session.exec(statement).first()
-            if s:
-                elapsed = ((s.end_time or datetime.now()) - s.start_time).total_seconds() / 60
-                return {'session_id': s.session_id, 'strategy': s.strategy, 'symbol': s.symbol, 'trade_amount': s.trade_amount,
-                        'is_running': s.is_running, 'position': 'FLAT', 'trades_count': s.trades_count, 'pnl': s.total_pnl, 
-                        'elapsed_minutes': round(elapsed, 1), 'remaining_minutes': 0, 'trades': []}
-    except Exception as e:
-        print(f"Error getting session status from DB: {e}")
-
-    return {"error": "Session not found"}
-
-
-def get_user_sessions(user_email: str) -> List[dict]:
-    """Get all sessions for a user."""
-    return get_user_sessions_from_db(user_email)
-
-
-# Available strategies for frontend
-AVAILABLE_STRATEGIES = [
-    {
-        "id": "hmm_svr",
-        "name": "HMM-SVR Medium Frequency",
-        "description": "Uses pre-trained HMM-SVR models for regime detection and volatility prediction. Trades every 3 hours with dynamic position sizing (0x-3x leverage based on market regime).",
-        "risk_level": "Medium",
-        "requires_symbol": True,
-        "requires_model": True,
-        "trade_interval": "3 hours"
-    }
-]

main.py

@@ -16,18 +16,6 @@ from jose import JWTError, jwt
 
 # Import your strategy logic
 from strategy import train_models_and_backtest
-from live_trading import (
-    get_account_balance,
-    get_portfolio_value,
-    get_recent_trades,
-    get_recent_trades_from_db,
-    get_current_price,
-    start_live_trading,
-    stop_live_trading,
-    get_session_status,
-    get_user_sessions,
-    AVAILABLE_STRATEGIES
-)
 
 # Import model manager for HMM-SVR models
 from model_manager import (
@@ -107,7 +95,7 @@ class Token(BaseModel):
     access_token: str
     token_type: str
 
-class LiveTradingRequest(BaseModel):
+class SimulatedTradingRequest(BaseModel):
     symbol: str
     trade_amount: float
     duration: int
@@ -333,89 +321,160 @@ def reload_models(current_user: str = Depends(get_current_user)):
     }
 
 
-# --- LIVE TRADING ROUTES ---
-
-@app.get("/api/live/strategies")
-def list_strategies(current_user: str = Depends(get_current_user)):
-    """Get list of available trading strategies"""
-    return {"strategies": AVAILABLE_STRATEGIES}
-
-
-@app.get("/api/live/portfolio")
-def get_portfolio(current_user: str = Depends(get_current_user)):
-    """Get current portfolio value and holdings"""
-    portfolio = get_portfolio_value()
-    if "error" in portfolio:
-        raise HTTPException(status_code=500, detail=portfolio["error"])
-    return portfolio
-
-
-@app.get("/api/live/balance")
-def get_balance(current_user: str = Depends(get_current_user)):
-    """Get account balances"""
-    balances = get_account_balance()
-    if isinstance(balances, dict) and "error" in balances:
-        raise HTTPException(status_code=500, detail=balances["error"])
-    return {"balances": balances}
-
-
-@app.get("/api/live/trades")
-def get_trades(symbol: Optional[str] = None, limit: int = 20, 
-               current_user: str = Depends(get_current_user)):
-    """Get recent trades from database for current user"""
-    trades = get_recent_trades_from_db(current_user, limit)
-    return {"trades": trades}
-
-
-@app.get("/api/live/price/{symbol}")
-def get_price(symbol: str, current_user: str = Depends(get_current_user)):
-    """Get current price for a symbol"""
-    price = get_current_price(symbol)
-    if price is None:
-        raise HTTPException(status_code=404, detail="Symbol not found")
-    return {"symbol": symbol, "price": price}
-
-
-@app.post("/api/live/start")
-def start_trading(req: LiveTradingRequest, current_user: str = Depends(get_current_user)):
-    """Start a live trading session"""
-    # Convert days to minutes if needed
-    duration_minutes = req.duration
-    if req.duration_unit == "days":
-        duration_minutes = req.duration * 24 * 60
+@app.get("/api/models/signal/{symbol}")
+def get_instant_signal(symbol: str, current_user: str = Depends(get_current_user)):
+    """
+    Get instant trading signal for a symbol using trained HMM-SVR model.
+    Auto-trains model if it doesn't exist.
+    Returns current regime, recommended position size, and trading signal.
     
-    result = start_live_trading(
-        user_email=current_user,
-        strategy=req.strategy,
-        symbol=req.symbol,
-        trade_amount=req.trade_amount,
-        duration_minutes=duration_minutes,
-        duration_unit=req.duration_unit,
-        short_window=req.short_window,
-        long_window=req.long_window,
-        interval=req.interval
-    )
-    if "error" in result:
-        raise HTTPException(status_code=400, detail=result["error"])
-    return result
-
-
-@app.post("/api/live/stop/{session_id}")
-def stop_trading(session_id: str, current_user: str = Depends(get_current_user)):
-    """Stop an active trading session"""
-    result = stop_live_trading(session_id)
-    if "error" in result:
-        raise HTTPException(status_code=404, detail=result["error"])
-    return result
+    Example: GET /api/models/signal/BTCUSDT
+    """
+    from model_manager import is_model_trained, load_model, calculate_signal_and_position, train_and_save_model
+    import yfinance as yf
+    from datetime import datetime, timedelta
+    import pandas as pd
+    
+    symbol = symbol.upper()
+    base_symbol = symbol.replace('USDT', '')
+    yahoo_symbol = f"{base_symbol}-USD"  # Convert to Yahoo Finance format
+    
+    # Check if model exists, train if not (same as bot auto-training)
+    if not is_model_trained(base_symbol) and not is_model_trained(symbol):
+        print(f"[SignalAPI] No model found for {base_symbol}, training now...")
+        
+        try:
+            # Train model with both Yahoo symbol and Binance symbol for fallback
+            # Save model with base symbol name (BNB) not Yahoo format (BNB-USD)
+            train_result = train_and_save_model(
+                symbol=yahoo_symbol, 
+                n_states=3, 
+                binance_symbol=symbol,
+                save_as=base_symbol
+            )
+            
+            if train_result and 'error' not in train_result:
+                print(f"[SignalAPI] ✅ Model trained for {base_symbol} with {train_result.get('train_days', 0)} days")
+            else:
+                return {
+                    "success": False,
+                    "error": f"Failed to train model: {train_result.get('error', 'Unknown error')}",
+                    "action_required": "Insufficient data to train model"
+                }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Model training failed: {str(e)}"
+            }
+    
+    # Fetch recent price data (450 days for proper feature calculation)
+    try:
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=450)
+        
+        df = yf.download(yahoo_symbol, start=start_date, end=end_date, progress=False, auto_adjust=True)
+        
+        if df.empty:
+            return {
+                "success": False,
+                "error": f"Could not fetch price data for {yahoo_symbol}"
+            }
+        
+        # Handle MultiIndex columns
+        if isinstance(df.columns, pd.MultiIndex):
+            if 'Close' in df.columns.get_level_values(0):
+                df.columns = df.columns.get_level_values(0)
+            else:
+                df.columns = df.columns.get_level_values(1)
+        
+        # Get signal from model (use base_symbol for model lookup, yahoo_symbol for data)
+        result = calculate_signal_and_position(
+            symbol=base_symbol,
+            recent_data=df,
+            short_window=12,
+            long_window=26
+        )
+        
+        if result is None or 'error' in result:
+            return {
+                "success": False,
+                "error": result.get('error', 'Unknown error') if result else "Failed to calculate signal"
+            }
+        
+        # Determine human-readable signal
+        ema_signal = result.get('ema_signal', 0)
+        target_position = result.get('target_position', 0)
+        position_multiplier = result.get('position_size_multiplier', 1.0)
+        regime = result.get('regime', 1)
+        regime_label = result.get('regime_label', 'Normal')
+        
+        # Generate action recommendation (5-level system: 0x, 0.5x, 1x, 2x, 3x)
+        if target_position == 0:
+            if regime_label == 'Crash':
+                action = "STAY OUT"
+                action_color = "red"
+                action_description = "🚨 Crash Protocol: Safety override activated"
+            else:
+                action = "WAIT"
+                action_color = "yellow"
+                action_description = "Bearish trend - waiting for reversal"
+        elif target_position == 3:
+            action = "STRONG BUY (3x)"
+            action_color = "green"
+            action_description = "🚀 Max Leverage: Safe regime + very low risk!"
+        elif target_position == 2:
+            action = "BUY (2x)"
+            action_color = "cyan"
+            action_description = "📈 Medium Leverage: Favorable conditions"
+        elif target_position == 0.5:
+            action = "CAUTIOUS BUY (0.5x)"
+            action_color = "orange"
+            action_description = "⚠️ Defensive: High risk detected"
+        else:
+            action = "BUY (1x)"
+            action_color = "blue"
+            action_description = "✅ Standard bullish position"
+        
+        return {
+            "success": True,
+            "symbol": symbol,
+            "current_price": result.get('close_price', 0),
+            "signal": {
+                "action": action,
+                "action_color": action_color,
+                "action_description": action_description,
+                "ema_trend": "Bullish" if ema_signal == 1 else "Bearish",
+                "position_multiplier": position_multiplier,
+                "target_position": target_position,
+                "signal_stability": result.get('signal_stability', 0.5),  # NEW
+                "ema_gap_percent": result.get('ema_gap_percent', 0)  # NEW: Trend strength
+            },
+            "regime": {
+                "state": regime,
+                "label": regime_label,
+                "description": "Low volatility" if regime == 0 else ("High volatility - danger" if regime_label == 'Crash' else "Normal volatility")
+            },
+            "risk": {
+                "ratio": result.get('risk_ratio', 1.0),
+                "level": "Low" if result.get('risk_ratio', 1.0) < 0.5 else ("High" if result.get('risk_ratio', 1.0) > 1.5 else "Moderate"),
+                "predicted_volatility": result.get('predicted_vol', 0)
+            },
+            "technicals": {
+                "ema_short": result.get('ema_short', 0),
+                "ema_long": result.get('ema_long', 0)
+            },
+            "reasoning": result.get('reasoning', ''),
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Error calculating signal: {str(e)}"
+        }
 
 
-@app.get("/api/live/session/{session_id}")
-def get_session(session_id: str, current_user: str = Depends(get_current_user)):
-    """Get status of a trading session"""
-    status = get_session_status(session_id)
-    if "error" in status:
-        raise HTTPException(status_code=404, detail=status["error"])
-    return status
+# --- SIMULATED TRADING ROUTES ---
 
 @app.get("/api/simulated/trades")
 def get_simulated_trades(
@@ -433,12 +492,6 @@ def get_simulated_sessions(current_user: str = Depends(get_current_user)):
     from simulated_endpoints import get_simulated_sessions_endpoint
     return get_simulated_sessions_endpoint(current_user)
 
-@app.get("/api/live/sessions")
-def get_sessions(current_user: str = Depends(get_current_user)):
-    """Get all trading sessions for the current user"""
-    sessions = get_user_sessions(current_user)
-    return {"sessions": sessions}
-
 
 @app.get("/api/simulated/portfolio")
 def get_simulated_portfolio(current_user: str = Depends(get_current_user)):
@@ -454,7 +507,7 @@ def get_simulated_portfolio(current_user: str = Depends(get_current_user)):
 
 
 @app.post("/api/simulated/start")
-def start_simulated_session(req: LiveTradingRequest, current_user: str = Depends(get_current_user)):
+def start_simulated_session(req: SimulatedTradingRequest, current_user: str = Depends(get_current_user)):
     """Start HMM-SVR trading bot session"""
     from simulated_trading import start_simulated_trading
     from database import initialize_portfolio_if_empty

model_manager.py

@@ -207,29 +207,43 @@ def train_svr_model(train_df: pd.DataFrame) -> Tuple[SVR, StandardScaler]:
     return model, scaler
 
 
-def train_and_save_model(symbol: str, n_states: int = 3) -> Dict[str, Any]:
+def train_and_save_model(symbol: str, n_states: int = 3, binance_symbol: str = None, save_as: str = None) -> Dict[str, Any]:
     """
     Train HMM-SVR models for a symbol and save to disk.
     Returns training results and metadata.
+    
+    Args:
+        symbol: Base symbol (e.g., 'BTC') or Yahoo Finance format (e.g., 'BTC-USD')
+        n_states: Number of HMM states (default 3)
+        binance_symbol: Full Binance symbol (e.g., 'BTCUSDT') for fallback, optional
+        save_as: Base symbol to use for saving model (e.g., 'BTC'). If not provided, 
+                 will auto-detect from symbol by stripping USDT/-USD suffixes
     """
+    # Auto-detect base symbol for saving if not provided
+    # Handles: BTCUSDT -> BTC, BTC-USD -> BTC, BTC -> BTC
+    if save_as is None:
+        save_as = symbol.replace('USDT', '').replace('-USD', '')
+    
     print(f"\n{'='*60}")
-    print(f"[ModelManager] Training HMM-SVR model for {symbol}")
+    print(f"[ModelManager] Training HMM-SVR model for {save_as}")
     print(f"{'='*60}")
     
     # Try Yahoo Finance first, then Binance
     df = fetch_training_data_yfinance(symbol)
     if df is None or len(df) < 250:
         print("[ModelManager] Falling back to Binance data...")
-        df = fetch_training_data_binance(symbol)
+        # Use full Binance symbol if provided, otherwise reconstruct it
+        fallback_symbol = binance_symbol if binance_symbol else f"{save_as}USDT"
+        df = fetch_training_data_binance(fallback_symbol)
     
     if df is None or len(df) < 250:
-        return {"error": f"Insufficient data for {symbol}. Need at least 250 days, got {len(df) if df is not None else 0}."}
+        return {"error": f"Insufficient data for {save_as}. Need at least 250 days, got {len(df) if df is not None else 0}."}
     
     # Engineer features
     df = engineer_features(df)
     
     if len(df) < 200:
-        return {"error": f"Insufficient data after feature engineering for {symbol}. Got {len(df)} days."}
+        return {"error": f"Insufficient data after feature engineering for {save_as}. Got {len(df)} days."}
     
     print(f"[ModelManager] Training on {len(df)} days of data...")
     
@@ -249,7 +263,7 @@ def train_and_save_model(symbol: str, n_states: int = 3) -> Dict[str, Any]:
     print("[ModelManager] Training SVR model...")
     svr_model, svr_scaler = train_svr_model(df)
     
-    # Prepare model data for saving
+    # Prepare model data for saving (use save_as for consistent base symbol)
     model_data = {
         'hmm_model': hmm_model,
         'svr_model': svr_model,
@@ -259,15 +273,15 @@ def train_and_save_model(symbol: str, n_states: int = 3) -> Dict[str, Any]:
         'n_states': n_states,
         'train_days': len(df),
         'trained_at': datetime.now().isoformat(),
-        'symbol': symbol
+        'symbol': save_as
     }
     
-    # Save to disk
-    model_path = get_model_path(symbol)
+    # Save to disk using base symbol (e.g., BTC not BTCUSDT or BTC-USD)
+    model_path = get_model_path(save_as)
     joblib.dump(model_data, model_path)
     
-    # Update cache
-    _model_cache[symbol.upper()] = model_data
+    # Update cache with base symbol
+    _model_cache[save_as.upper()] = model_data
     
     print(f"[ModelManager] ✅ Model saved to {model_path}")
     print(f"[ModelManager] States: 0=Low Vol (Safe), {n_states-1}=High Vol (Crash)")
@@ -275,7 +289,7 @@ def train_and_save_model(symbol: str, n_states: int = 3) -> Dict[str, Any]:
     
     return {
         "success": True,
-        "symbol": symbol,
+        "symbol": save_as,
         "trained_at": model_data['trained_at'],
         "train_days": len(df),
         "avg_train_vol": avg_train_vol,
@@ -408,13 +422,15 @@ def calculate_signal_and_position(
     symbol: str,
     recent_data: pd.DataFrame,
     short_window: int = 12,
-    long_window: int = 26
+    long_window: int = 26,
+    lookback_window: int = 252
 ) -> Optional[Dict[str, Any]]:
     """
-   
+    Calculate trading signal and position sizing with walk-forward logic.
+    Enhanced to match backtest methodology more closely.
     
     Returns:
-        Dict with signal, target_position_size, regime info, etc.
+        Dict with signal, target_position_size, regime info, stability metrics, etc.
     """
     # Get regime and volatility prediction
     prediction = predict_regime_and_volatility(symbol, recent_data)
@@ -424,35 +440,84 @@ def calculate_signal_and_position(
     model_data = load_model(symbol)
     n_states = model_data['n_states']
     
-    # Calculate EMAs on recent data
+    # Use sliding window for EMA calculation (matches backtest)
     df = recent_data.copy()
-    df['EMA_Short'] = df['Close'].ewm(span=short_window).mean()
-    df['EMA_Long'] = df['Close'].ewm(span=long_window).mean()
+    lookback_data = df.iloc[-lookback_window:] if len(df) > lookback_window else df
     
-    latest = df.iloc[-1]
+    # Calculate EMAs on sliding window only (not full history)
+    lookback_data_copy = lookback_data.copy()
+    lookback_data_copy['EMA_Short'] = lookback_data_copy['Close'].ewm(span=short_window).mean()
+    lookback_data_copy['EMA_Long'] = lookback_data_copy['Close'].ewm(span=long_window).mean()
+    
+    latest = lookback_data_copy.iloc[-1]
     
     # EMA Crossover Signal (1 = bullish, 0 = bearish)
     ema_signal = 1 if latest['EMA_Short'] > latest['EMA_Long'] else 0
     
+    # Calculate signal stability (how long has signal been consistent?)
+    if len(lookback_data_copy) >= 5:
+        recent_5_days = lookback_data_copy.tail(5)
+        recent_signals = (recent_5_days['EMA_Short'] > recent_5_days['EMA_Long']).astype(int)
+        signal_stability = recent_signals.sum() / 5.0  # 1.0 = all bullish, 0.0 = all bearish
+    else:
+        signal_stability = 0.5
+    
     # Determine position size based on regime and risk
     regime = prediction['regime']
     risk_ratio = prediction['risk_ratio']
     
-    # Default position size
-    position_size = 1.0
+    # Enhanced 5-level leverage logic:
+    # - 0x: Crash regime OR bearish trend
+    # - 0.5x: High risk in normal regime (defensive)
+    # - 1x: Standard bullish position
+    # - 2x: Safe regime with moderate risk OR normal regime with low risk
+    # - 3x: Safe regime + very low risk (sniper mode)
+    
+    position_size = 1.0  # Default: Standard position
     
-    # Boost: 3x in safe regime with low risk
-    if regime == 0 and risk_ratio < 0.5:
-        position_size = 3.0
+    # Debug logging to verify conditions
+    print(f"[Leverage Logic] {symbol}: Regime={regime}/{n_states-1}, Risk={risk_ratio:.3f}, EMA_Signal={ema_signal}")
     
-    # Cut: 0x in crash regime (highest volatility state)
+    # CRASH PROTOCOL: Override to 0x if crash regime detected
     if regime == n_states - 1:
         position_size = 0.0
+        print(f"[Leverage Logic] {symbol}: CRASH REGIME → 0x position")
+    
+    # SAFE REGIME (Lowest volatility)
+    elif regime == 0:
+        if risk_ratio < 0.5:
+            position_size = 3.0  # 🚀 SNIPER MODE
+            print(f"[Leverage Logic] {symbol}: SNIPER MODE (Safe + Very Low Risk) → 3x")
+        elif risk_ratio < 0.85:
+            position_size = 2.0  # 📈 Strong position
+            print(f"[Leverage Logic] {symbol}: Safe + Moderate Risk → 2x")
+        else:
+            position_size = 1.0  # ✅ Standard
+            print(f"[Leverage Logic] {symbol}: Safe + High Risk → 1x")
+    
+    # NORMAL REGIME (Middle volatility)
+    elif regime == 1:
+        if risk_ratio < 0.5:
+            position_size = 2.0  # 📈 Favorable
+            print(f"[Leverage Logic] {symbol}: Normal + Low Risk → 2x")
+        elif risk_ratio > 1.2:
+            position_size = 0.5  # ⚠️ Defensive
+            print(f"[Leverage Logic] {symbol}: Normal + High Risk → 0.5x (defensive)")
+        else:
+            position_size = 1.0  # ✅ Standard
+            print(f"[Leverage Logic] {symbol}: Normal + Moderate Risk → 1x")
+    
+    # Otherwise: Standard 1x position (if bullish) or 0x (if bearish)
     
     # Target position = Signal * Position Size
     # Signal of 0 means no position regardless of size
     target_position = ema_signal * position_size
     
+    # Enhanced reasoning with stability context
+    reasoning = _get_signal_reasoning(
+        ema_signal, regime, risk_ratio, position_size, n_states, signal_stability
+    )
+    
     return {
         'ema_signal': ema_signal,
         'ema_short': float(latest['EMA_Short']),
@@ -464,44 +529,57 @@ def calculate_signal_and_position(
         'position_size_multiplier': position_size,
         'target_position': target_position,  # 0, 1, or 3
         'close_price': float(latest['Close']),
-        'reasoning': _get_signal_reasoning(ema_signal, regime, risk_ratio, position_size, n_states)
+        'signal_stability': signal_stability,  # NEW: How stable is the signal?
+        'reasoning': reasoning,
+        'ema_gap_percent': ((latest['EMA_Short'] - latest['EMA_Long']) / latest['EMA_Long'] * 100)  # NEW: Strength of trend
     }
 
 
 def _get_signal_reasoning(ema_signal: int, regime: int, risk_ratio: float, 
-                          position_size: float, n_states: int) -> str:
-    """Generate human-readable reasoning for the signal."""
+                          position_size: float, n_states: int, signal_stability: float = 0.5) -> str:
+    """Generate human-readable reasoning for the signal with stability context."""
     reasons = []
     
-    # EMA reasoning
+    # EMA reasoning with stability
     if ema_signal == 1:
-        reasons.append("EMA crossover bullish (short > long)")
+        stability_text = "STRONG" if signal_stability > 0.8 else ("WEAK" if signal_stability < 0.4 else "MODERATE")
+        reasons.append(f"✅ Trend UP (12-EMA > 26-EMA) [{stability_text}]")
     else:
-        reasons.append("EMA crossover bearish (short < long)")
+        stability_text = "STRONG" if signal_stability < 0.2 else ("WEAK" if signal_stability > 0.6 else "MODERATE")
+        reasons.append(f"📉 Trend DOWN (12-EMA < 26-EMA) [{stability_text}]")
     
     # Regime reasoning
     if regime == 0:
-        reasons.append("Safe regime detected (low volatility)")
+        reasons.append("🛡️ Safe Regime (Low Volatility)")
     elif regime == n_states - 1:
-        reasons.append("⚠️ Crash regime detected (high volatility)")
+        reasons.append("🚨 CRASH REGIME (High Volatility)")
     else:
-        reasons.append(f"Normal regime ({regime})")
+        reasons.append(f"⚖️ Normal Regime (Neutral Volatility)")
     
     # Risk reasoning
     if risk_ratio < 0.5:
-        reasons.append(f"Low risk (ratio: {risk_ratio:.2f})")
+        reasons.append(f"🌤️ Future Looks Calm (risk: {risk_ratio:.2f})")
     elif risk_ratio > 1.5:
-        reasons.append(f"High risk (ratio: {risk_ratio:.2f})")
+        reasons.append(f"⚠️ High Future Risk (risk: {risk_ratio:.2f})")
     else:
-        reasons.append(f"Moderate risk (ratio: {risk_ratio:.2f})")
+        reasons.append(f"📊 Normal Risk (ratio: {risk_ratio:.2f})")
     
-    # Position reasoning
+    # Position reasoning with enhanced logic
     if position_size == 3.0:
-        reasons.append("→ Leveraging 3x (safe + low risk)")
+        reasons.append("→ 🚀 MAX LEVERAGE 3x (Sniper Mode!)")
+    elif position_size == 2.0:
+        reasons.append("→ 📈 MEDIUM LEVERAGE 2x (Favorable)")
+    elif position_size == 1.0:
+        reasons.append("→ ✅ Standard 1x Position")
+    elif position_size == 0.5:
+        reasons.append("→ ⚠️ REDUCED 0.5x (Defensive)")
     elif position_size == 0.0:
-        reasons.append("→ Position cut to 0 (crash regime)")
+        if regime == n_states - 1:
+            reasons.append("→ 🛑 CASH (Crash Protocol Override)")
+        else:
+            reasons.append("→ 🛑 CASH (Bearish Trend)")
     else:
-        reasons.append("→ Standard 1x position")
+        reasons.append(f"→ Position: {position_size:.1f}x")
     
     return " | ".join(reasons)
 

simulated_trading.py

@@ -135,25 +135,27 @@ class SimulatedTradingSession:
                 return
             
             # Get signal from HMM-SVR model
-            signal = self.handler.get_signal(price)
+            signal, position_size = self.handler.get_signal(price)
             
             # Log check
             elapsed_hours = (datetime.now() - self.start_time).total_seconds() / 3600
             position_str = self.position or 'NONE'
-            print(f"[HMM-SVR Bot] ⏰ Check | {elapsed_hours:.1f}h | ${price:,.2f} | {signal} | Pos: {position_str}")
+            print(f"[HMM-SVR Bot] ⏰ Check | {elapsed_hours:.1f}h | ${price:,.2f} | {signal} {position_size}x | Pos: {position_str}")
             
             # Execute based on signal (long-only strategy)
             if signal == "BUY" and self.position is None:
-                self._open_long_position(price)
+                self._open_long_position(price, position_size)
             elif signal == "SELL" and self.position == "LONG":
                 self._close_position(price)
             
         except Exception as e:
             print(f"[HMM-SVR Bot] ❌ Error: {e}")
     
-    def _open_long_position(self, price: float):
-        """Open a LONG position (BUY)"""
-        quantity = self.trade_amount / price
+    def _open_long_position(self, price: float, position_size: float = 1.0):
+        """Open a LONG position (BUY) with leverage multiplier"""
+        # Apply position size multiplier (0x, 1x, or 3x)
+        leveraged_amount = self.trade_amount * position_size
+        quantity = leveraged_amount / price
         
         success, trade_info = simulated_exchange.execute_buy(
             symbol=self.base_asset,
@@ -166,7 +168,8 @@ class SimulatedTradingSession:
             self.position = "LONG"
             self.entry_price = price
             self._save_trade_to_db(trade_info)
-            print(f"[HMM-SVR Bot] 📈 LONG opened: {quantity:.8f} {self.base_asset} @ ${price:,.2f}")
+            leverage_str = f" ({position_size}x)" if position_size != 1.0 else ""
+            print(f"[HMM-SVR Bot] 📈 LONG opened: {quantity:.8f} {self.base_asset} @ ${price:,.2f}{leverage_str}")
         else:
             print(f"[HMM-SVR Bot] ❌ Failed to open position")
     

strategy_handlers.py

@@ -72,21 +72,21 @@ class HMMSVRStrategyHandler:
         except Exception as e:
             print(f"[HMM-SVR] ⚠️ Error loading historical data: {e}")
     
-    def get_signal(self, price: float) -> str:
+    def get_signal(self, price: float) -> tuple[str, float]:
         """
         Generate trading signal using HMM-SVR model.
         
         Returns:
-            "BUY" - open/increase position
-            "SELL" - close position
-            "HOLD" - maintain current state
+            tuple: (signal, position_size)
+                - signal: "BUY", "SELL", or "HOLD"
+                - position_size: 0.0 (no position), 1.0 (normal), 3.0 (high conviction)
         """
         # Add current price to buffer
         self.price_buffer.append(float(price))
         
         # Need at least 100 data points
         if len(self.price_buffer) < 100:
-            return "HOLD"
+            return "HOLD", 0.0
         
         try:
             # Convert buffer to DataFrame for model
@@ -104,7 +104,7 @@ class HMMSVRStrategyHandler:
             
             if result is None or 'error' in result:
                 print(f"[HMM-SVR] Error: {result}")
-                return "HOLD"
+                return "HOLD", self.last_position_size
             
             # Extract results
             target_position = result.get('target_position_size', 0.0)
@@ -123,8 +123,8 @@ class HMMSVRStrategyHandler:
                 signal = "HOLD"
             
             self.last_position_size = target_position
-            return signal
+            return signal, target_position
             
         except Exception as e:
             print(f"[HMM-SVR] Error generating signal: {e}")
-            return "HOLD"
+            return "HOLD", self.last_position_size