Initial deployment of Zyon Traders Backend10

.env.example

@@ -1,27 +1,137 @@
 # Zyon Traders Backend Environment Variables
 # Copy this file to .env and fill in your actual values
 
-# App Configuration
+# =============================================================================
+# APPLICATION CONFIGURATION
+# =============================================================================
 DEBUG=false
-SECRET_KEY=your-secret-key-here
-ALLOWED_ORIGINS=https://your-frontend-domain.com
+SECRET_KEY=your-secret-key-here-change-in-production
+PORT=7860
+LOG_LEVEL=INFO
+
+# =============================================================================
+# CORS AND SECURITY
+# =============================================================================
+# Comma-separated list of allowed origins
+ALLOWED_ORIGINS=http://localhost:3000,http://localhost:5173,https://your-frontend-domain.com
+
+# =============================================================================
+# DATABASE CONFIGURATION
+# =============================================================================
+# Optional: Direct database URL
+DATABASE_URL=postgresql://user:password@localhost:5432/zyon_traders
 
-# Supabase Configuration
+# Supabase Configuration (Primary database)
 SUPABASE_PROJECT_URL=https://your-project.supabase.co
 SUPABASE_ANON_KEY=your-supabase-anon-key
+SUPABASE_SERVICE_ROLE_KEY=your-supabase-service-role-key
 
-# Dhan Trading API
-DHAN_API_KEY=your-dhan-api-key
+# =============================================================================
+# DHAN API CONFIGURATION
+# =============================================================================
+# Base API URL (usually doesn't need to change)
+DHAN_API_BASE_URL=https://api.dhan.co/v2
 
-# AI Services
-GEMINI_API_KEY=your-gemini-api-key
+# Trading Mode: "live", "paper", or "sandbox"
+DHAN_TRADING_MODE=live
+
+# Live Trading Configuration
+DHAN_CLIENT_ID=your-live-client-id
+DHAN_TRADING_API_TOKEN=your-trading-api-token
+DHAN_DATA_API_TOKEN=your-data-api-token
+
+# Paper Trading Configuration (for testing without real money)
+DHAN_PAPER_TRADING_CLIENT_ID=your-paper-client-id
+DHAN_PAPER_TRADING_TOKEN=your-paper-trading-token
+
+# WebSocket URLs (usually don't need to change)
+DHAN_WS_MARKET_FEED_URL=wss://api-feed.dhan.co
+DHAN_WS_ORDER_UPDATE_URL=wss://api-order-update.dhan.co
+DHAN_WS_MARKET_DEPTH_URL=wss://depth-api-feed.dhan.co/twentydepth
+
+# Legacy API configuration (for backward compatibility)
+DHAN_API_KEY=your-legacy-api-key
+DHAN_ACCESS_TOKEN=your-legacy-access-token
+
+# =============================================================================
+# AI SERVICES CONFIGURATION
+# =============================================================================
+# AI model API keys (optional)
 TOGETHER_API_KEY=your-together-api-key
 FIREWORKS_API_KEY=your-fireworks-api-key
-HUGGINGFACE_API_KEY=your-huggingface-api-key
+GEMINI_API_KEY=your-gemini-api-key
 LANGCHAIN_API_KEY=your-langchain-api-key
+HUGGINGFACE_API_KEY=your-huggingface-api-key
 
-# External Services
+# =============================================================================
+# EXTERNAL SERVICES
+# =============================================================================
+# Monitoring and alerting
 UPTIMEROBOT_API_KEY=your-uptimerobot-key
 
-# Logging
-LOG_LEVEL=INFO
+# Redis for caching (optional)
+REDIS_URL=redis://localhost:6379
+
+# =============================================================================
+# HUGGINGFACE SPACES CONFIGURATION
+# =============================================================================
+# These are automatically set by HuggingFace Spaces
+SPACE_ID=your-space-id
+SPACE_AUTHOR_NAME=your-username
+
+# =============================================================================
+# PERFORMANCE AND LIMITS
+# =============================================================================
+# Rate limiting
+RATE_LIMIT_PER_MINUTE=100
+
+# WebSocket settings
+WS_HEARTBEAT_INTERVAL=30
+WS_MAX_CONNECTIONS=1000
+
+# =============================================================================
+# DHAN API TOKEN SETUP GUIDE
+# =============================================================================
+# 
+# 1. TRADING API TOKEN:
+#    - Used for: Placing orders, managing positions, checking funds
+#    - Get from: Dhan API portal under "Trading API"
+#    - Set as: DHAN_TRADING_API_TOKEN
+#
+# 2. DATA API TOKEN:
+#    - Used for: Real-time quotes, historical data, market feeds
+#    - Get from: Dhan API portal under "Data API"
+#    - Set as: DHAN_DATA_API_TOKEN
+#
+# 3. PAPER TRADING TOKEN:
+#    - Used for: Testing strategies without real money
+#    - Get from: Dhan API portal under "Paper Trading"
+#    - Set as: DHAN_PAPER_TRADING_TOKEN
+#    - Also set: DHAN_PAPER_TRADING_CLIENT_ID
+#
+# 4. TRADING MODE:
+#    - Set to "paper" for testing with paper trading
+#    - Set to "live" for real trading
+#    - The system will automatically use the appropriate tokens
+#
+# =============================================================================
+# DEPLOYMENT NOTES
+# =============================================================================
+#
+# For HuggingFace Spaces:
+# - PORT should be 7860 (automatically set)
+# - Add your HF Space URL to ALLOWED_ORIGINS
+# - Set DEBUG=false for production
+#
+# For Local Development:
+# - PORT can be 8000 or any available port
+# - Set DEBUG=true
+# - Add localhost URLs to ALLOWED_ORIGINS
+#
+# For Production Deployment:
+# - Always set DEBUG=false
+# - Use strong SECRET_KEY
+# - Set appropriate ALLOWED_ORIGINS
+# - Use environment-specific database URLs
+#
+# =============================================================================

Dockerfile

@@ -4,7 +4,7 @@ FROM python:3.10-slim
 # Set environment variables
 ENV PYTHONDONTWRITEBYTECODE=1
 ENV PYTHONUNBUFFERED=1
-ENV PORT=8000
+ENV PORT=7860
 
 # Set work directory
 WORKDIR /app
@@ -35,9 +35,9 @@ USER app
 # Expose port
 EXPOSE $PORT
 
-# Health check
+# Health check (use fixed port for HF Spaces)
 HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
-    CMD curl -f http://localhost:$PORT/api/health || exit 1
+    CMD curl -f http://localhost:7860/api/health || exit 1
 
 # Run the application (HuggingFace Spaces compatible)
 CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

config/settings.py

@@ -1,58 +1,101 @@
 """
 Application settings and configuration
-Environment-based configuration for production deployment
+Environment-based configuration for HuggingFace Spaces deployment
 """
 
 import os
 from typing import List, Optional
-from pydantic import BaseSettings, validator
+from pydantic import BaseSettings, validator, Field
 from functools import lru_cache
 
 class Settings(BaseSettings):
     """Application settings"""
     
     # Basic app config
-    DEBUG: bool = False
-    SECRET_KEY: str = "your-secret-key-change-in-production"
+    DEBUG: bool = Field(default=False, env="DEBUG")
+    SECRET_KEY: str = Field(default="your-secret-key-change-in-production", env="SECRET_KEY")
     API_V1_STR: str = "/api"
     PROJECT_NAME: str = "Zyon Traders API"
     
-    # Server config
+    # Server config - HF Spaces uses port 7860
     HOST: str = "0.0.0.0"
-    PORT: int = 8000
+    PORT: int = Field(default=7860, env="PORT")
     
-    # CORS settings
+    # CORS settings - Updated for HF Spaces compatibility
     ALLOWED_ORIGINS: List[str] = [
         "http://localhost:3000",
+        "http://localhost:5173",  # Vite dev server
         "http://localhost:8080",
-        "https://zyon-traders.netlify.app",  # Your frontend URL
-        "https://your-domain.com"  # Replace with your actual domain
+        "https://zyon-traders.netlify.app",
+        "https://zyonpackers-zyon-traders-backend.hf.space",
+        "https://huggingface.co",
+        "https://*.hf.space",
+        "https://*.netlify.app", 
+        "https://*.vercel.app",
+        "https://*.surge.sh"
     ]
     
     # Database
     DATABASE_URL: Optional[str] = None
     
-    # Supabase
-    SUPABASE_PROJECT_URL: str
-    SUPABASE_ANON_KEY: str
-    SUPABASE_SERVICE_ROLE_KEY: Optional[str] = None
+    # Supabase - with defaults for HF Spaces
+    SUPABASE_PROJECT_URL: str = Field(
+        default="https://placeholder.supabase.co",
+        env="SUPABASE_PROJECT_URL"
+    )
+    SUPABASE_ANON_KEY: str = Field(
+        default="placeholder-anon-key",
+        env="SUPABASE_ANON_KEY"
+    )
+    SUPABASE_SERVICE_ROLE_KEY: Optional[str] = Field(default=None, env="SUPABASE_SERVICE_ROLE_KEY")
     
-    # Dhan API
-    DHAN_API_KEY: str
+    # Dhan API Configuration
     DHAN_API_BASE_URL: str = "https://api.dhan.co/v2"
+    DHAN_CLIENT_ID: str = "1107671523"
+
+    # Trading Environment Mode
+    DHAN_TRADING_MODE: str = Field(default="live", env="DHAN_TRADING_MODE")
+
+    # Trading API - For order management, portfolio, funds
+    DHAN_TRADING_API_TOKEN: str = Field(
+        default="eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzUxMiJ9.eyJpc3MiOiJkaGFuIiwicGFydG5lcklkIjoiIiwiZXhwIjoxNzU0NTQ1Nzg5LCJ0b2tlbkNvbnN1bWVyVHlwZSI6IlNFTEYiLCJ3ZWJob29rVXJsIjoiIiwiZGhhbkNsaWVudElkIjoiMTEwNzY3MTUyMyJ9.FJUHdkfv4MNNkM-_1AidgRGzch5xI8fBbpb-IZNF0O4sD6TkliY0pQaJ0mlTjX58UrCdzmbTDLziJwVmZeOmxA",
+        env="DHAN_TRADING_API_TOKEN"
+    )
+
+    # Data API - For real-time market data, quotes, historical data
+    DHAN_DATA_API_TOKEN: str = Field(
+        default="eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzUxMiJ9.eyJpc3MiOiJkaGFuIiwicGFydG5lcklkIjoiIiwiZXhwIjoxNzU0NTQ2MjI2LCJ0b2tlbkNvbnN1bWVyVHlwZSI6IlNFTEYiLCJ3ZWJob29rVXJsIjoiIiwiZGhhbkNsaWVudElkIjoiMTEwNzY3MTUyMyJ9.lvaxN5oI3h3_t3cTA-uCWsyh3909hdgBKmQMZDgspCxfkHN-Lh9QcoApy12GUdEvXgVs2oYwdUAdTnuPYuX78g",
+        env="DHAN_DATA_API_TOKEN"
+    )
+
+    # Paper Trading (Sandbox) API - For testing without real money
+    DHAN_PAPER_TRADING_CLIENT_ID: str = "2507087705"
+    DHAN_PAPER_TRADING_TOKEN: str = Field(
+        default="eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJ0b2tlbkNvbnN1bWVyVHlwZSI6IlNFTEYiLCJwYXJ0bmVySWQiOiIiLCJkaGFuQ2xpZW50SWQiOiIyNTA3MDg3NzA1Iiwid2ViaG9va1VybCI6Imh0dHBzOi8vMmZjNmMyYzc4MzQxNDIxYWIyMzc2YTM1YTdhNTViZTItOWE5NGRhZDEzNTc0NDMyM2I4N2YxNTc5ZS5mbHkuZGV2L2F1dGgvY2FsbGJhY2siLCJpc3MiOiJkaGFuIiwiZXhwIjoxNzU0NTgyMTQ1fQ.K_hIOXtkVmrqEfNH18nm-wuA1DxkReIAi7zWcBzDF-gEGYkZDzcnxPVNz2anDIzJM65Kr1SvV1L0brOfOawR3A",
+        env="DHAN_PAPER_TRADING_TOKEN"
+    )
+
+    # Dhan WebSocket endpoints
+    DHAN_WS_MARKET_FEED_URL: str = "wss://api-feed.dhan.co"
+    DHAN_WS_ORDER_UPDATE_URL: str = "wss://api-order-update.dhan.co"
+    DHAN_WS_MARKET_DEPTH_URL: str = "wss://depth-api-feed.dhan.co/twentydepth"
+
+    # Legacy support (for backward compatibility)
+    DHAN_API_KEY: Optional[str] = Field(default=None, env="DHAN_API_KEY")
+    DHAN_ACCESS_TOKEN: Optional[str] = Field(default=None, env="DHAN_ACCESS_TOKEN")
     
     # AI Services
-    TOGETHER_API_KEY: Optional[str] = None
-    FIREWORKS_API_KEY: Optional[str] = None
-    GEMINI_API_KEY: Optional[str] = None
-    LANGCHAIN_API_KEY: Optional[str] = None
-    HUGGINGFACE_API_KEY: Optional[str] = None
+    TOGETHER_API_KEY: Optional[str] = Field(default=None, env="TOGETHER_API_KEY")
+    FIREWORKS_API_KEY: Optional[str] = Field(default=None, env="FIREWORKS_API_KEY")
+    GEMINI_API_KEY: Optional[str] = Field(default=None, env="GEMINI_API_KEY")
+    LANGCHAIN_API_KEY: Optional[str] = Field(default=None, env="LANGCHAIN_API_KEY")
+    HUGGINGFACE_API_KEY: Optional[str] = Field(default=None, env="HUGGINGFACE_API_KEY")
     
     # External Services
-    UPTIMEROBOT_API_KEY: Optional[str] = None
+    UPTIMEROBOT_API_KEY: Optional[str] = Field(default=None, env="UPTIMEROBOT_API_KEY")
     
     # Redis (for caching - optional)
-    REDIS_URL: Optional[str] = None
+    REDIS_URL: Optional[str] = Field(default=None, env="REDIS_URL")
     
     # Rate limiting
     RATE_LIMIT_PER_MINUTE: int = 100
@@ -62,24 +105,135 @@ class Settings(BaseSettings):
     WS_MAX_CONNECTIONS: int = 1000
     
     # Logging
-    LOG_LEVEL: str = "INFO"
+    LOG_LEVEL: str = Field(default="INFO", env="LOG_LEVEL")
+    
+    # HuggingFace Spaces specific settings
+    SPACE_ID: Optional[str] = Field(default=None, env="SPACE_ID")
+    SPACE_AUTHOR_NAME: Optional[str] = Field(default=None, env="SPACE_AUTHOR_NAME")
     
     @validator("ALLOWED_ORIGINS", pre=True)
-    def assemble_cors_origins(cls, v: str) -> List[str]:
-        if isinstance(v, str) and not v.startswith("["):
-            return [i.strip() for i in v.split(",")]
-        elif isinstance(v, (list, str)):
+    def assemble_cors_origins(cls, v) -> List[str]:
+        """Parse CORS origins from environment variable or list"""
+        if isinstance(v, str):
+            if v.startswith("["):
+                try:
+                    import json
+                    return json.loads(v)
+                except Exception:
+                    pass
+            # Handle comma-separated string
+            origins = [i.strip() for i in v.split(",") if i.strip()]
+            
+            # Add wildcard support for HF Spaces if needed
+            if any("hf.space" in origin for origin in origins):
+                origins.append("*")  # Allow all for iframe compatibility
+            
+            return origins
+        elif isinstance(v, list):
             return v
-        raise ValueError(v)
+        return [str(v)] if v else ["*"]
+    
+    @validator("PORT", pre=True)
+    def validate_port(cls, v):
+        """Ensure port is integer and within valid range"""
+        try:
+            port = int(v)
+            if 1 <= port <= 65535:
+                return port
+            return 7860  # Default HF Spaces port
+        except (ValueError, TypeError):
+            return 7860
+    
+    @validator("DEBUG", pre=True)
+    def validate_debug(cls, v):
+        """Parse DEBUG from various string formats"""
+        if isinstance(v, str):
+            return v.lower() in ("true", "1", "yes", "on")
+        return bool(v)
+    
+    @validator("DHAN_TRADING_MODE")
+    def validate_trading_mode(cls, v):
+        """Validate trading mode is one of allowed values"""
+        allowed_modes = ["live", "paper", "sandbox"]
+        if v.lower() not in allowed_modes:
+            return "live"  # Default to live
+        return v.lower()
+    
+    def get_cors_origins(self) -> List[str]:
+        """Get CORS origins with HF Spaces compatibility"""
+        origins = self.ALLOWED_ORIGINS.copy()
+        
+        # Ensure HF Spaces compatibility
+        if not any("*" in origin for origin in origins):
+            # Add wildcard for development and iframe compatibility
+            if self.DEBUG:
+                origins.append("*")
+        
+        return origins
+    
+    def is_production(self) -> bool:
+        """Check if running in production environment"""
+        return not self.DEBUG and "hf.space" in str(self.SPACE_ID or "")
+    
+    def get_database_url(self) -> Optional[str]:
+        """Get database URL with fallback to Supabase"""
+        if self.DATABASE_URL:
+            return self.DATABASE_URL
+        
+        # Construct from Supabase settings if available
+        if (self.SUPABASE_PROJECT_URL != "https://placeholder.supabase.co" and 
+            self.SUPABASE_SERVICE_ROLE_KEY):
+            # Extract project ID from URL
+            try:
+                project_id = self.SUPABASE_PROJECT_URL.split("//")[1].split(".")[0]
+                return f"postgresql://postgres:[password]@db.{project_id}.supabase.co:5432/postgres"
+            except Exception:
+                pass
+        
+        return None
     
     class Config:
         env_file = ".env"
         case_sensitive = True
+        # Allow extra fields for flexibility in different environments
+        extra = "allow"
+        # Enable environment variable parsing
+        env_file_encoding = 'utf-8'
 
 @lru_cache()
 def get_settings() -> Settings:
     """Get cached settings instance"""
     return Settings()
 
-# For Render.com deployment, settings will be loaded from environment variables
+# Create settings instance for import
 settings = get_settings()
+
+# Environment-specific configurations
+def configure_for_environment():
+    """Configure settings based on environment"""
+    current_settings = get_settings()
+    
+    # HuggingFace Spaces specific configuration
+    if current_settings.SPACE_ID:
+        # Ensure CORS is properly configured for HF Spaces
+        if "*" not in current_settings.ALLOWED_ORIGINS:
+            current_settings.ALLOWED_ORIGINS.append("*")
+        
+        # Set production flags
+        current_settings.DEBUG = False
+    
+    # Development environment
+    elif current_settings.DEBUG:
+        # Add development-friendly CORS
+        dev_origins = [
+            "http://localhost:3000",
+            "http://localhost:5173", 
+            "http://127.0.0.1:3000",
+            "http://127.0.0.1:5173"
+        ]
+        for origin in dev_origins:
+            if origin not in current_settings.ALLOWED_ORIGINS:
+                current_settings.ALLOWED_ORIGINS.append(origin)
+
+# Apply environment configuration
+configure_for_environment()

main.py

@@ -16,7 +16,8 @@ import os
 from datetime import datetime, timedelta
 
 # Import routers
-from routers import auth, signals, dhan, portfolio, screener, analytics
+from routers import auth, signals, portfolio, screener, analytics
+from routers import dhan_new as dhan
 from services.websocket_manager import WebSocketManager
 from config.settings import get_settings
 from utils.logging_config import setup_logging
@@ -62,13 +63,14 @@ app = FastAPI(
     lifespan=lifespan
 )
 
-# CORS middleware
+# CORS middleware for Hugging Face Spaces compatibility
 app.add_middleware(
     CORSMiddleware,
     allow_origins=settings.ALLOWED_ORIGINS,
     allow_credentials=True,
-    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD"],
     allow_headers=["*"],
+    expose_headers=["*"],  # Important for HF Spaces
 )
 
 # Include routers
@@ -91,18 +93,31 @@ async def root():
 
 @app.get("/api/health")
 async def health_check():
-    """Detailed health check"""
+    """Detailed health check for Hugging Face Spaces"""
     return {
         "status": "healthy",
         "timestamp": datetime.utcnow().isoformat(),
         "version": "1.0.0",
+        "environment": "huggingface_spaces",
+        "port": int(os.getenv("PORT", 7860)),
         "services": {
             "database": "connected",
             "dhan_api": "connected",
-            "ai_services": "connected"
+            "ai_services": "connected",
+            "websocket": "available"
+        },
+        "endpoints": {
+            "api_base": "/api",
+            "websocket": "/ws",
+            "docs": "/docs" if settings.DEBUG else None
         }
     }
 
+@app.get("/health")
+async def simple_health_check():
+    """Simple health check for HF Spaces monitoring"""
+    return {"status": "ok", "timestamp": datetime.utcnow().isoformat()}
+
 @app.websocket("/ws")
 async def websocket_endpoint(websocket: WebSocket):
     """WebSocket endpoint for real-time data"""
@@ -144,10 +159,14 @@ async def global_exception_handler(request, exc):
 
 if __name__ == "__main__":
     import uvicorn
+    # Hugging Face Spaces uses port 7860 by default
+    port = int(os.getenv("PORT", 7860))
     uvicorn.run(
         "main:app",
         host="0.0.0.0",
-        port=int(os.getenv("PORT", 8000)),
+        port=port,
         reload=settings.DEBUG,
-        log_level="info"
+        log_level="info",
+        proxy_headers=True,  # Required for HF Spaces proxy
+        forwarded_allow_ips="*"  # Allow forwarded IPs from HF proxy
     )

models/portfolio.py

@@ -0,0 +1,239 @@
+"""
+Pydantic models for portfolio management
+"""
+
+from pydantic import BaseModel, Field, validator
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+from enum import Enum
+
+class RiskLevel(str, Enum):
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+class AssetClass(str, Enum):
+    EQUITY = "equity"
+    DEBT = "debt"
+    COMMODITY = "commodity"
+    CURRENCY = "currency"
+    HYBRID = "hybrid"
+
+class PortfolioSummary(BaseModel):
+    total_value: float = Field(..., description="Total portfolio value")
+    total_invested: float = Field(..., description="Total amount invested")
+    total_pnl: float = Field(..., description="Total profit/loss")
+    pnl_percentage: float = Field(..., description="P&L percentage")
+    day_change: float = Field(..., description="Day's change in value")
+    day_change_percentage: float = Field(..., description="Day's change percentage")
+    holdings_count: int = Field(..., description="Number of holdings")
+    last_updated: datetime = Field(..., description="Last update timestamp")
+
+class PortfolioHolding(BaseModel):
+    security_id: str = Field(..., description="Security ID")
+    symbol: str = Field(..., description="Trading symbol")
+    quantity: int = Field(..., description="Quantity held")
+    average_price: float = Field(..., description="Average buy price")
+    current_price: float = Field(..., description="Current market price")
+    current_value: float = Field(..., description="Current market value")
+    invested_value: float = Field(..., description="Total invested amount")
+    pnl: float = Field(..., description="Profit/loss amount")
+    pnl_percentage: float = Field(..., description="P&L percentage")
+    day_change: float = Field(..., description="Day's change")
+    day_change_percentage: float = Field(..., description="Day's change percentage")
+    sector: Optional[str] = Field(None, description="Sector classification")
+    asset_class: AssetClass = Field(..., description="Asset class")
+
+class PortfolioPosition(BaseModel):
+    security_id: str = Field(..., description="Security ID")
+    symbol: str = Field(..., description="Trading symbol")
+    quantity: int = Field(..., description="Net quantity")
+    buy_quantity: int = Field(..., description="Buy quantity")
+    sell_quantity: int = Field(..., description="Sell quantity")
+    buy_average: float = Field(..., description="Average buy price")
+    sell_average: float = Field(..., description="Average sell price")
+    realized_pnl: float = Field(..., description="Realized P&L")
+    unrealized_pnl: float = Field(..., description="Unrealized P&L")
+    current_price: float = Field(..., description="Current market price")
+    product_type: str = Field(..., description="Product type")
+
+class RiskMetrics(BaseModel):
+    beta: float = Field(..., description="Portfolio beta")
+    alpha: float = Field(..., description="Portfolio alpha")
+    sharpe_ratio: float = Field(..., description="Sharpe ratio")
+    sortino_ratio: float = Field(..., description="Sortino ratio")
+    volatility: float = Field(..., description="Portfolio volatility")
+    value_at_risk_1d: float = Field(..., description="1-day Value at Risk")
+    value_at_risk_5d: float = Field(..., description="5-day Value at Risk")
+    maximum_drawdown: float = Field(..., description="Maximum drawdown")
+    correlation_with_market: float = Field(..., description="Correlation with market")
+
+class PerformanceMetrics(BaseModel):
+    total_return: float = Field(..., description="Total return")
+    annualized_return: float = Field(..., description="Annualized return")
+    best_day: float = Field(..., description="Best single day return")
+    worst_day: float = Field(..., description="Worst single day return")
+    positive_days: int = Field(..., description="Number of positive days")
+    negative_days: int = Field(..., description="Number of negative days")
+    win_rate: float = Field(..., description="Win rate percentage")
+    calmar_ratio: float = Field(..., description="Calmar ratio")
+    tracking_error: float = Field(..., description="Tracking error")
+
+class SectorAllocation(BaseModel):
+    sector: str = Field(..., description="Sector name")
+    allocation_percentage: float = Field(..., description="Allocation percentage")
+    current_value: float = Field(..., description="Current value")
+    pnl: float = Field(..., description="Sector P&L")
+    pnl_percentage: float = Field(..., description="Sector P&L percentage")
+
+class AssetAllocation(BaseModel):
+    asset_class: AssetClass = Field(..., description="Asset class")
+    allocation_percentage: float = Field(..., description="Allocation percentage")
+    current_value: float = Field(..., description="Current value")
+    target_percentage: Optional[float] = Field(None, description="Target allocation")
+
+class RiskAssessment(BaseModel):
+    overall_risk_score: float = Field(..., ge=0, le=10, description="Overall risk score (0-10)")
+    risk_level: RiskLevel = Field(..., description="Risk level category")
+    concentration_risk: float = Field(..., description="Concentration risk score")
+    sector_concentration: Dict[str, float] = Field(..., description="Sector concentration")
+    liquidity_risk: float = Field(..., description="Liquidity risk score")
+    currency_risk: float = Field(..., description="Currency risk score")
+    recommendations: List[str] = Field(..., description="Risk mitigation recommendations")
+
+class AllocationRequest(BaseModel):
+    target_allocations: List[AssetAllocation] = Field(..., description="Target asset allocations")
+    rebalancing_threshold: float = Field(5.0, ge=1, le=20, description="Rebalancing threshold percentage")
+    investment_amount: Optional[float] = Field(None, description="Additional investment amount")
+
+class PortfolioOptimization(BaseModel):
+    optimization_objective: str = Field(..., description="Optimization objective")
+    expected_return: float = Field(..., description="Expected return")
+    expected_risk: float = Field(..., description="Expected risk")
+    efficient_frontier: List[Dict[str, float]] = Field(..., description="Efficient frontier points")
+    optimal_weights: Dict[str, float] = Field(..., description="Optimal asset weights")
+    suggested_changes: List[Dict[str, Any]] = Field(..., description="Suggested portfolio changes")
+
+class RebalancingPlan(BaseModel):
+    current_allocation: List[AssetAllocation] = Field(..., description="Current allocation")
+    target_allocation: List[AssetAllocation] = Field(..., description="Target allocation")
+    required_trades: List[Dict[str, Any]] = Field(..., description="Required trades")
+    estimated_cost: float = Field(..., description="Estimated transaction cost")
+    tax_implications: float = Field(..., description="Estimated tax implications")
+    net_benefit: float = Field(..., description="Net benefit after costs")
+
+class PortfolioAlert(BaseModel):
+    alert_type: str = Field(..., description="Type of alert")
+    severity: str = Field(..., description="Alert severity")
+    message: str = Field(..., description="Alert message")
+    affected_securities: List[str] = Field(..., description="Affected securities")
+    recommended_action: str = Field(..., description="Recommended action")
+    created_at: datetime = Field(..., description="Alert creation time")
+
+class DiversificationMetrics(BaseModel):
+    herfindahl_index: float = Field(..., description="Herfindahl concentration index")
+    effective_holdings: int = Field(..., description="Effective number of holdings")
+    sector_diversification: float = Field(..., description="Sector diversification score")
+    geographic_diversification: float = Field(..., description="Geographic diversification score")
+    market_cap_diversification: float = Field(..., description="Market cap diversification score")
+    diversification_score: float = Field(..., ge=0, le=100, description="Overall diversification score")
+
+class CorrelationMatrix(BaseModel):
+    securities: List[str] = Field(..., description="List of securities")
+    correlation_data: List[List[float]] = Field(..., description="Correlation matrix data")
+    average_correlation: float = Field(..., description="Average correlation")
+    max_correlation: float = Field(..., description="Maximum correlation")
+    min_correlation: float = Field(..., description="Minimum correlation")
+
+class PortfolioComparison(BaseModel):
+    portfolio_return: float = Field(..., description="Portfolio return")
+    benchmark_return: float = Field(..., description="Benchmark return")
+    alpha: float = Field(..., description="Alpha vs benchmark")
+    beta: float = Field(..., description="Beta vs benchmark")
+    tracking_error: float = Field(..., description="Tracking error")
+    information_ratio: float = Field(..., description="Information ratio")
+    up_capture: float = Field(..., description="Up market capture ratio")
+    down_capture: float = Field(..., description="Down market capture ratio")
+
+class StressTestResult(BaseModel):
+    scenario_name: str = Field(..., description="Stress test scenario name")
+    scenario_description: str = Field(..., description="Scenario description")
+    portfolio_impact: float = Field(..., description="Portfolio impact amount")
+    impact_percentage: float = Field(..., description="Impact as percentage")
+    worst_affected_holdings: List[Dict[str, Any]] = Field(..., description="Most affected holdings")
+    recommendations: List[str] = Field(..., description="Risk mitigation recommendations")
+
+class TaxOptimization(BaseModel):
+    current_year: int = Field(..., description="Tax year")
+    realized_gains: float = Field(..., description="Realized capital gains")
+    realized_losses: float = Field(..., description="Realized capital losses")
+    unrealized_gains: float = Field(..., description="Unrealized capital gains")
+    unrealized_losses: float = Field(..., description="Unrealized capital losses")
+    tax_liability: float = Field(..., description="Estimated tax liability")
+    loss_harvesting_opportunities: List[Dict[str, Any]] = Field(..., description="Tax loss harvesting opportunities")
+    ltcg_stcg_breakdown: Dict[str, float] = Field(..., description="Long-term vs short-term gains")
+
+class PortfolioInsights(BaseModel):
+    top_contributors: List[Dict[str, Any]] = Field(..., description="Top contributing holdings")
+    top_detractors: List[Dict[str, Any]] = Field(..., description="Top detracting holdings")
+    momentum_stocks: List[Dict[str, Any]] = Field(..., description="Stocks with positive momentum")
+    lagging_stocks: List[Dict[str, Any]] = Field(..., description="Underperforming stocks")
+    overweight_sectors: List[str] = Field(..., description="Overweight sectors")
+    underweight_sectors: List[str] = Field(..., description="Underweight sectors")
+    key_insights: List[str] = Field(..., description="Key portfolio insights")
+
+class PortfolioHealthScore(BaseModel):
+    overall_score: float = Field(..., ge=0, le=100, description="Overall portfolio health score")
+    diversification_score: float = Field(..., description="Diversification component score")
+    performance_score: float = Field(..., description="Performance component score")
+    risk_score: float = Field(..., description="Risk management component score")
+    cost_efficiency_score: float = Field(..., description="Cost efficiency score")
+    liquidity_score: float = Field(..., description="Liquidity score")
+    score_breakdown: Dict[str, float] = Field(..., description="Detailed score breakdown")
+    improvement_suggestions: List[str] = Field(..., description="Suggestions for improvement")
+
+# Response Models
+class PortfolioResponse(BaseModel):
+    summary: PortfolioSummary
+    holdings: List[PortfolioHolding]
+    positions: List[PortfolioPosition]
+    risk_metrics: RiskMetrics
+    performance_metrics: PerformanceMetrics
+    sector_allocation: List[SectorAllocation]
+    asset_allocation: List[AssetAllocation]
+    last_updated: datetime
+
+class PortfolioAnalyticsResponse(BaseModel):
+    portfolio_summary: PortfolioSummary
+    risk_assessment: RiskAssessment
+    performance_metrics: PerformanceMetrics
+    diversification_metrics: DiversificationMetrics
+    portfolio_insights: PortfolioInsights
+    health_score: PortfolioHealthScore
+    alerts: List[PortfolioAlert]
+    timestamp: datetime
+
+# Request Models
+class PortfolioOptimizationRequest(BaseModel):
+    objective: str = Field("max_sharpe", description="Optimization objective")
+    constraints: Dict[str, Any] = Field(default_factory=dict, description="Optimization constraints")
+    risk_tolerance: RiskLevel = Field(RiskLevel.MEDIUM, description="Risk tolerance")
+    investment_horizon: str = Field("medium", description="Investment horizon")
+
+class RebalancingRequest(BaseModel):
+    target_allocation: List[AssetAllocation] = Field(..., description="Target asset allocation")
+    rebalancing_frequency: str = Field("quarterly", description="Rebalancing frequency")
+    threshold_percentage: float = Field(5.0, description="Rebalancing threshold")
+    tax_optimization: bool = Field(True, description="Consider tax implications")
+
+class PortfolioBacktestRequest(BaseModel):
+    start_date: str = Field(..., description="Backtest start date")
+    end_date: str = Field(..., description="Backtest end date")
+    initial_amount: float = Field(..., description="Initial investment amount")
+    rebalancing_frequency: str = Field("monthly", description="Rebalancing frequency")
+    benchmark: str = Field("NIFTY50", description="Benchmark for comparison")
+
+class StressTestRequest(BaseModel):
+    scenarios: List[str] = Field(..., description="Stress test scenarios to run")
+    confidence_levels: List[float] = Field([0.95, 0.99], description="Confidence levels for VaR")
+    time_horizons: List[int] = Field([1, 5, 21], description="Time horizons in days")

models/signals.py

@@ -0,0 +1,288 @@
+"""
+Pydantic models for AI trading signals
+"""
+
+from pydantic import BaseModel, Field, validator
+from typing import List, Optional, Dict, Any, Union
+from datetime import datetime
+from enum import Enum
+
+class SignalType(str, Enum):
+    BUY = "BUY"
+    SELL = "SELL"
+    HOLD = "HOLD"
+    STRONG_BUY = "STRONG_BUY"
+    STRONG_SELL = "STRONG_SELL"
+
+class SignalStrength(str, Enum):
+    WEAK = "weak"
+    MODERATE = "moderate"
+    STRONG = "strong"
+    VERY_STRONG = "very_strong"
+
+class TimeFrame(str, Enum):
+    INTRADAY = "intraday"
+    SHORT_TERM = "short_term"  # 1-7 days
+    MEDIUM_TERM = "medium_term"  # 1-4 weeks
+    LONG_TERM = "long_term"  # 1+ months
+
+class IndicatorType(str, Enum):
+    TECHNICAL = "technical"
+    FUNDAMENTAL = "fundamental"
+    SENTIMENT = "sentiment"
+    QUANTITATIVE = "quantitative"
+    HYBRID = "hybrid"
+
+class MarketCondition(str, Enum):
+    BULLISH = "bullish"
+    BEARISH = "bearish"
+    SIDEWAYS = "sideways"
+    VOLATILE = "volatile"
+
+class AnalysisType(str, Enum):
+    TECHNICAL = "technical"
+    FUNDAMENTAL = "fundamental"
+    QUANTITATIVE = "quantitative"
+    SENTIMENT = "sentiment"
+    AI_ML = "ai_ml"
+
+# Core Signal Models
+class TechnicalIndicator(BaseModel):
+    name: str = Field(..., description="Indicator name (e.g., RSI, MACD, SMA)")
+    value: float = Field(..., description="Current indicator value")
+    signal: SignalType = Field(..., description="Signal generated by this indicator")
+    strength: SignalStrength = Field(..., description="Signal strength")
+    description: str = Field(..., description="Human-readable description")
+
+class FundamentalMetric(BaseModel):
+    metric_name: str = Field(..., description="Fundamental metric name")
+    current_value: float = Field(..., description="Current value")
+    industry_average: Optional[float] = Field(None, description="Industry average")
+    percentile_rank: Optional[float] = Field(None, description="Percentile rank")
+    trend: str = Field(..., description="Trend direction")
+    impact: str = Field(..., description="Impact on signal")
+
+class SentimentIndicator(BaseModel):
+    source: str = Field(..., description="Sentiment data source")
+    score: float = Field(..., ge=-1, le=1, description="Sentiment score (-1 to 1)")
+    confidence: float = Field(..., ge=0, le=1, description="Confidence in sentiment")
+    key_factors: List[str] = Field(..., description="Key sentiment drivers")
+    news_count: int = Field(..., description="Number of news articles analyzed")
+
+class AISignal(BaseModel):
+    model_name: str = Field(..., description="AI model that generated the signal")
+    prediction: SignalType = Field(..., description="Model prediction")
+    confidence_score: float = Field(..., ge=0, le=1, description="Model confidence")
+    feature_importance: Dict[str, float] = Field(..., description="Feature importance scores")
+    prediction_horizon: str = Field(..., description="Time horizon for prediction")
+
+# Main Signal Response Model
+class SignalResponse(BaseModel):
+    signal_id: str = Field(..., description="Unique signal identifier")
+    security_id: str = Field(..., description="Security ID")
+    symbol: str = Field(..., description="Trading symbol")
+    exchange_segment: str = Field(..., description="Exchange segment")
+    
+    # Core signal information
+    signal_type: SignalType = Field(..., description="Primary signal type")
+    signal_strength: SignalStrength = Field(..., description="Overall signal strength")
+    confidence_score: float = Field(..., ge=0, le=1, description="Overall confidence")
+    time_frame: TimeFrame = Field(..., description="Signal time frame")
+    
+    # Price and target information
+    current_price: float = Field(..., description="Current market price")
+    target_price: Optional[float] = Field(None, description="Target price")
+    stop_loss: Optional[float] = Field(None, description="Stop loss price")
+    entry_price_range: Optional[Dict[str, float]] = Field(None, description="Optimal entry range")
+    
+    # Analysis components
+    technical_analysis: List[TechnicalIndicator] = Field(default_factory=list, description="Technical indicators")
+    fundamental_analysis: List[FundamentalMetric] = Field(default_factory=list, description="Fundamental metrics")
+    sentiment_analysis: List[SentimentIndicator] = Field(default_factory=list, description="Sentiment indicators")
+    ai_analysis: List[AISignal] = Field(default_factory=list, description="AI model predictions")
+    
+    # Additional metadata
+    risk_rating: str = Field(..., description="Risk rating for the signal")
+    expected_return: Optional[float] = Field(None, description="Expected return percentage")
+    probability_of_success: Optional[float] = Field(None, description="Success probability")
+    market_condition: MarketCondition = Field(..., description="Current market condition")
+    
+    # Timestamps
+    generated_at: datetime = Field(..., description="Signal generation timestamp")
+    valid_until: Optional[datetime] = Field(None, description="Signal expiry timestamp")
+    
+    # Human-readable summary
+    summary: str = Field(..., description="Human-readable signal summary")
+    reasoning: str = Field(..., description="Detailed reasoning behind the signal")
+    key_catalysts: List[str] = Field(default_factory=list, description="Key catalysts driving the signal")
+    
+    @validator('target_price', 'stop_loss')
+    def validate_price_levels(cls, v, values, field):
+        if v is not None and 'current_price' in values:
+            current_price = values['current_price']
+            signal_type = values.get('signal_type')
+            
+            if field.name == 'target_price' and signal_type in ['BUY', 'STRONG_BUY'] and v <= current_price:
+                raise ValueError('Target price should be higher than current price for buy signals')
+            elif field.name == 'target_price' and signal_type in ['SELL', 'STRONG_SELL'] and v >= current_price:
+                raise ValueError('Target price should be lower than current price for sell signals')
+            elif field.name == 'stop_loss' and signal_type in ['BUY', 'STRONG_BUY'] and v >= current_price:
+                raise ValueError('Stop loss should be lower than current price for buy signals')
+            elif field.name == 'stop_loss' and signal_type in ['SELL', 'STRONG_SELL'] and v <= current_price:
+                raise ValueError('Stop loss should be higher than current price for sell signals')
+        
+        return v
+
+# Request Models
+class SecurityRequest(BaseModel):
+    security_id: str = Field(..., description="Security ID")
+    exchange_segment: str = Field(..., description="Exchange segment")
+
+class SignalRequest(BaseModel):
+    securities: List[SecurityRequest] = Field(..., description="Securities to analyze")
+    analysis_types: List[AnalysisType] = Field(..., description="Types of analysis to perform")
+    time_frames: List[TimeFrame] = Field(..., description="Time frames for analysis")
+    preferences: Optional[Dict[str, Any]] = Field(None, description="User preferences for signal generation")
+    
+    @validator('securities')
+    def validate_securities_count(cls, v):
+        if len(v) > 50:
+            raise ValueError('Maximum 50 securities allowed per request')
+        return v
+
+class SignalFilter(BaseModel):
+    signal_types: Optional[List[SignalType]] = Field(None, description="Filter by signal types")
+    signal_strength: Optional[List[SignalStrength]] = Field(None, description="Filter by signal strength")
+    time_frames: Optional[List[TimeFrame]] = Field(None, description="Filter by time frames")
+    min_confidence: Optional[float] = Field(None, ge=0, le=1, description="Minimum confidence score")
+    symbols: Optional[List[str]] = Field(None, description="Filter by symbols")
+    date_from: Optional[datetime] = Field(None, description="Filter signals from date")
+    date_to: Optional[datetime] = Field(None, description="Filter signals to date")
+    risk_rating: Optional[List[str]] = Field(None, description="Filter by risk rating")
+
+class UserPreferences(BaseModel):
+    risk_tolerance: str = Field("medium", description="Risk tolerance level")
+    investment_horizon: TimeFrame = Field(TimeFrame.MEDIUM_TERM, description="Preferred investment horizon")
+    preferred_indicators: List[str] = Field(default_factory=list, description="Preferred technical indicators")
+    sectors_to_include: List[str] = Field(default_factory=list, description="Preferred sectors")
+    sectors_to_exclude: List[str] = Field(default_factory=list, description="Sectors to avoid")
+    min_market_cap: Optional[float] = Field(None, description="Minimum market cap filter")
+    max_market_cap: Optional[float] = Field(None, description="Maximum market cap filter")
+    esg_preference: bool = Field(False, description="Prefer ESG-compliant stocks")
+
+# Market Analysis Models
+class MarketTrend(BaseModel):
+    trend_direction: str = Field(..., description="Overall trend direction")
+    trend_strength: SignalStrength = Field(..., description="Trend strength")
+    support_levels: List[float] = Field(..., description="Key support levels")
+    resistance_levels: List[float] = Field(..., description="Key resistance levels")
+    trend_duration: int = Field(..., description="Trend duration in days")
+
+class SectorAnalysis(BaseModel):
+    sector_name: str = Field(..., description="Sector name")
+    performance: float = Field(..., description="Sector performance percentage")
+    outlook: str = Field(..., description="Sector outlook")
+    key_drivers: List[str] = Field(..., description="Key sector drivers")
+    top_stocks: List[str] = Field(..., description="Top performing stocks in sector")
+    recommendation: SignalType = Field(..., description="Sector recommendation")
+
+class MarketAnalysisResponse(BaseModel):
+    overall_market_sentiment: str = Field(..., description="Overall market sentiment")
+    market_trend: MarketTrend = Field(..., description="Current market trend")
+    volatility_index: float = Field(..., description="Market volatility index")
+    fear_greed_index: int = Field(..., ge=0, le=100, description="Fear & Greed Index")
+    sector_analysis: List[SectorAnalysis] = Field(..., description="Sector-wise analysis")
+    macro_factors: List[str] = Field(..., description="Key macroeconomic factors")
+    market_events: List[str] = Field(..., description="Upcoming market events")
+    generated_at: datetime = Field(..., description="Analysis generation time")
+
+# Backtesting and Performance Models
+class BacktestResult(BaseModel):
+    start_date: datetime = Field(..., description="Backtest start date")
+    end_date: datetime = Field(..., description="Backtest end date")
+    total_signals: int = Field(..., description="Total signals generated")
+    successful_signals: int = Field(..., description="Number of successful signals")
+    accuracy_rate: float = Field(..., ge=0, le=1, description="Signal accuracy rate")
+    total_return: float = Field(..., description="Total return percentage")
+    annualized_return: float = Field(..., description="Annualized return")
+    max_drawdown: float = Field(..., description="Maximum drawdown")
+    sharpe_ratio: float = Field(..., description="Sharpe ratio")
+    win_rate: float = Field(..., description="Win rate percentage")
+    average_win: float = Field(..., description="Average winning trade")
+    average_loss: float = Field(..., description="Average losing trade")
+    profit_factor: float = Field(..., description="Profit factor")
+
+class SignalPerformance(BaseModel):
+    signal_id: str = Field(..., description="Signal identifier")
+    entry_price: float = Field(..., description="Actual entry price")
+    exit_price: Optional[float] = Field(None, description="Actual exit price")
+    return_percentage: Optional[float] = Field(None, description="Return percentage")
+    holding_period: Optional[int] = Field(None, description="Holding period in days")
+    status: str = Field(..., description="Signal status (open/closed/expired)")
+    outcome: Optional[str] = Field(None, description="Signal outcome (success/failure)")
+
+# Alert and Notification Models
+class SignalAlert(BaseModel):
+    alert_id: str = Field(..., description="Alert identifier")
+    user_id: str = Field(..., description="User identifier")
+    symbol: str = Field(..., description="Symbol to watch")
+    condition: str = Field(..., description="Alert condition")
+    threshold: float = Field(..., description="Alert threshold")
+    signal_type: SignalType = Field(..., description="Signal type to trigger")
+    is_active: bool = Field(True, description="Alert active status")
+    created_at: datetime = Field(..., description="Alert creation time")
+    triggered_at: Optional[datetime] = Field(None, description="Alert trigger time")
+
+class NotificationPreference(BaseModel):
+    email_enabled: bool = Field(True, description="Email notifications enabled")
+    sms_enabled: bool = Field(False, description="SMS notifications enabled")
+    push_enabled: bool = Field(True, description="Push notifications enabled")
+    signal_types: List[SignalType] = Field(..., description="Signal types to notify")
+    min_confidence: float = Field(0.7, description="Minimum confidence for notifications")
+    time_frames: List[TimeFrame] = Field(..., description="Time frames for notifications")
+
+# Custom Strategy Models
+class StrategyRule(BaseModel):
+    rule_type: str = Field(..., description="Type of rule (technical/fundamental/custom)")
+    parameter: str = Field(..., description="Parameter name")
+    operator: str = Field(..., description="Comparison operator")
+    value: Union[float, str] = Field(..., description="Threshold value")
+    weight: float = Field(1.0, description="Rule weight in strategy")
+
+class CustomStrategy(BaseModel):
+    strategy_id: str = Field(..., description="Strategy identifier")
+    name: str = Field(..., description="Strategy name")
+    description: str = Field(..., description="Strategy description")
+    rules: List[StrategyRule] = Field(..., description="Strategy rules")
+    signal_threshold: float = Field(..., description="Signal generation threshold")
+    risk_management: Dict[str, Any] = Field(..., description="Risk management parameters")
+    backtest_results: Optional[BacktestResult] = Field(None, description="Backtesting results")
+    is_active: bool = Field(True, description="Strategy active status")
+    created_by: str = Field(..., description="Strategy creator")
+    created_at: datetime = Field(..., description="Strategy creation time")
+
+# Signal Statistics and Analytics
+class SignalStatistics(BaseModel):
+    total_signals_generated: int = Field(..., description="Total signals generated")
+    signals_by_type: Dict[str, int] = Field(..., description="Signals breakdown by type")
+    signals_by_strength: Dict[str, int] = Field(..., description="Signals breakdown by strength")
+    average_confidence: float = Field(..., description="Average confidence score")
+    success_rate: float = Field(..., description="Overall success rate")
+    top_performing_symbols: List[Dict[str, Any]] = Field(..., description="Best performing symbols")
+    model_performance: Dict[str, float] = Field(..., description="Individual model performance")
+    last_updated: datetime = Field(..., description="Last update timestamp")
+
+# Batch Processing Models
+class BatchSignalRequest(BaseModel):
+    securities: List[SecurityRequest] = Field(..., description="Securities to analyze")
+    analysis_config: Dict[str, Any] = Field(..., description="Analysis configuration")
+    callback_url: Optional[str] = Field(None, description="Callback URL for results")
+    priority: str = Field("normal", description="Processing priority")
+    
+class BatchSignalResponse(BaseModel):
+    batch_id: str = Field(..., description="Batch processing ID")
+    status: str = Field(..., description="Batch processing status")
+    total_securities: int = Field(..., description="Total securities in batch")
+    completed_securities: int = Field(..., description="Completed securities count")
+    estimated_completion: Optional[datetime] = Field(None, description="Estimated completion time")
+    results_url: Optional[str] = Field(None, description="Results download URL")

routers/analytics.py

@@ -0,0 +1,479 @@
+"""
+Analytics Router
+Handles portfolio analytics, market analysis, and reporting
+"""
+
+from fastapi import APIRouter, HTTPException, Depends, Query
+from typing import List, Dict, Any, Optional
+import logging
+from datetime import datetime, timedelta
+
+from config.settings import get_settings
+from services.auth import get_current_user
+from services.dhan_api_manager import dhan_api_manager, DhanAPIError
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+settings = get_settings()
+
+@router.get("/portfolio-analytics")
+async def get_portfolio_analytics(
+    period: str = Query("1Y", description="Analysis period (1M, 3M, 6M, 1Y, 2Y)"),
+    current_user: Dict = Depends(get_current_user)
+):
+    """Get comprehensive portfolio analytics"""
+    try:
+        # Get holdings and positions
+        holdings_result = await dhan_api_manager.get_holdings()
+        positions_result = await dhan_api_manager.get_positions()
+        
+        holdings = holdings_result.get("data", [])
+        positions = positions_result.get("data", [])
+        
+        # Calculate analytics (mock implementation)
+        total_value = sum(holding.get("currentValue", 0) for holding in holdings)
+        total_pnl = sum(holding.get("pnl", 0) for holding in holdings)
+        total_invested = total_value - total_pnl
+        
+        return {
+            "portfolio_value": total_value,
+            "total_invested": total_invested,
+            "total_pnl": total_pnl,
+            "pnl_percentage": (total_pnl / total_invested * 100) if total_invested > 0 else 0,
+            "holdings_count": len(holdings),
+            "positions_count": len(positions),
+            "period": period,
+            "analytics": {
+                "best_performer": get_best_performer(holdings),
+                "worst_performer": get_worst_performer(holdings),
+                "sector_allocation": calculate_sector_allocation(holdings),
+                "risk_metrics": calculate_risk_metrics(holdings),
+                "performance_metrics": calculate_performance_metrics(holdings, period)
+            },
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error in portfolio analytics: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error generating portfolio analytics: {e}")
+        raise HTTPException(status_code=500, detail="Failed to generate portfolio analytics")
+
+@router.get("/market-analytics")
+async def get_market_analytics(
+    indices: List[str] = Query(["NIFTY", "SENSEX"], description="Market indices to analyze"),
+    current_user: Dict = Depends(get_current_user)
+):
+    """Get market analytics and trends"""
+    try:
+        # Mock market analytics
+        market_data = {}
+        
+        for index in indices:
+            # In a real implementation, you'd fetch live market data
+            mock_data = {
+                "NIFTY": {
+                    "current_value": 22150.50,
+                    "change": 185.75,
+                    "change_percent": 0.85,
+                    "volume": 156789000,
+                    "market_cap": 28500000000000,
+                    "pe_ratio": 22.5,
+                    "dividend_yield": 1.25
+                },
+                "SENSEX": {
+                    "current_value": 72890.25,
+                    "change": 425.80,
+                    "change_percent": 0.59,
+                    "volume": 98456000,
+                    "market_cap": 35600000000000,
+                    "pe_ratio": 24.8,
+                    "dividend_yield": 1.15
+                }
+            }
+            
+            market_data[index] = mock_data.get(index, {
+                "current_value": 0,
+                "change": 0,
+                "change_percent": 0,
+                "volume": 0
+            })
+        
+        return {
+            "market_data": market_data,
+            "market_sentiment": {
+                "overall": "Bullish",
+                "fear_greed_index": 72,
+                "volatility_index": 18.5,
+                "advance_decline_ratio": 1.8
+            },
+            "sector_trends": [
+                {"sector": "IT", "trend": "Bullish", "change_percent": 2.1},
+                {"sector": "Banking", "trend": "Bearish", "change_percent": -0.8},
+                {"sector": "Auto", "trend": "Neutral", "change_percent": 0.3}
+            ],
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+    except Exception as e:
+        logger.error(f"Error generating market analytics: {e}")
+        raise HTTPException(status_code=500, detail="Failed to generate market analytics")
+
+@router.get("/trading-analytics")
+async def get_trading_analytics(
+    period: str = Query("1M", description="Analysis period"),
+    current_user: Dict = Depends(get_current_user)
+):
+    """Get trading performance analytics"""
+    try:
+        # Get orders for the period
+        orders_result = await dhan_api_manager.get_orders()
+        orders = orders_result.get("data", [])
+        
+        # Calculate trading analytics (mock implementation)
+        total_trades = len(orders)
+        successful_trades = len([order for order in orders if order.get("orderStatus") == "COMPLETE"])
+        
+        return {
+            "trading_summary": {
+                "total_trades": total_trades,
+                "successful_trades": successful_trades,
+                "success_rate": (successful_trades / total_trades * 100) if total_trades > 0 else 0,
+                "win_rate": 65.5,  # Mock data
+                "average_profit": 2.8,  # Mock data
+                "average_loss": -1.5,  # Mock data
+                "profit_factor": 1.85,  # Mock data
+                "sharpe_ratio": 1.42  # Mock data
+            },
+            "trade_distribution": {
+                "by_type": {
+                    "BUY": len([o for o in orders if o.get("transactionType") == "BUY"]),
+                    "SELL": len([o for o in orders if o.get("transactionType") == "SELL"])
+                },
+                "by_product": {
+                    "CNC": len([o for o in orders if o.get("productType") == "CNC"]),
+                    "MIS": len([o for o in orders if o.get("productType") == "MIS"]),
+                    "NRML": len([o for o in orders if o.get("productType") == "NRML"])
+                }
+            },
+            "monthly_performance": generate_monthly_performance(),
+            "period": period,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error in trading analytics: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error generating trading analytics: {e}")
+        raise HTTPException(status_code=500, detail="Failed to generate trading analytics")
+
+@router.get("/risk-analytics")
+async def get_risk_analytics(
+    current_user: Dict = Depends(get_current_user)
+):
+    """Get portfolio risk analytics"""
+    try:
+        # Get portfolio data
+        holdings_result = await dhan_api_manager.get_holdings()
+        holdings = holdings_result.get("data", [])
+        
+        # Calculate risk metrics (mock implementation)
+        portfolio_value = sum(holding.get("currentValue", 0) for holding in holdings)
+        
+        return {
+            "risk_metrics": {
+                "portfolio_beta": 1.15,
+                "value_at_risk_1d": portfolio_value * 0.02,  # 2% VaR
+                "value_at_risk_5d": portfolio_value * 0.045,  # 4.5% VaR
+                "maximum_drawdown": 12.5,
+                "volatility": 18.7,
+                "correlation_with_market": 0.85,
+                "concentration_risk": calculate_concentration_risk(holdings)
+            },
+            "stress_testing": {
+                "market_crash_scenario": {
+                    "scenario": "20% market decline",
+                    "portfolio_impact": portfolio_value * -0.23,
+                    "impact_percentage": -23.0
+                },
+                "sector_shock": {
+                    "scenario": "IT sector 15% decline", 
+                    "portfolio_impact": portfolio_value * -0.08,
+                    "impact_percentage": -8.0
+                }
+            },
+            "risk_score": 7.2,  # Out of 10
+            "risk_category": "Moderate-High",
+            "recommendations": [
+                "Consider diversifying into defensive sectors",
+                "Reduce exposure to high-beta stocks",
+                "Add some fixed-income instruments"
+            ],
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error in risk analytics: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error generating risk analytics: {e}")
+        raise HTTPException(status_code=500, detail="Failed to generate risk analytics")
+
+@router.get("/performance-report")
+async def generate_performance_report(
+    start_date: str = Query(..., description="Start date (YYYY-MM-DD)"),
+    end_date: str = Query(..., description="End date (YYYY-MM-DD)"),
+    format: str = Query("json", description="Report format (json, pdf)"),
+    current_user: Dict = Depends(get_current_user)
+):
+    """Generate comprehensive performance report"""
+    try:
+        # Parse dates
+        start_dt = datetime.strptime(start_date, "%Y-%m-%d")
+        end_dt = datetime.strptime(end_date, "%Y-%m-%d")
+        
+        if start_dt >= end_dt:
+            raise HTTPException(status_code=400, detail="Start date must be before end date")
+        
+        # Get portfolio data
+        holdings_result = await dhan_api_manager.get_holdings()
+        orders_result = await dhan_api_manager.get_orders()
+        
+        holdings = holdings_result.get("data", [])
+        orders = orders_result.get("data", [])
+        
+        # Generate report
+        report = {
+            "report_period": {
+                "start_date": start_date,
+                "end_date": end_date,
+                "duration_days": (end_dt - start_dt).days
+            },
+            "portfolio_summary": {
+                "current_value": sum(h.get("currentValue", 0) for h in holdings),
+                "total_pnl": sum(h.get("pnl", 0) for h in holdings),
+                "number_of_holdings": len(holdings),
+                "number_of_trades": len(orders)
+            },
+            "performance_metrics": {
+                "absolute_return": 8.5,  # Mock data
+                "annualized_return": 12.8,
+                "volatility": 18.5,
+                "sharpe_ratio": 1.42,
+                "max_drawdown": 15.2,
+                "calmar_ratio": 0.85
+            },
+            "benchmark_comparison": {
+                "portfolio_return": 8.5,
+                "nifty_return": 6.2,
+                "alpha": 2.3,
+                "beta": 1.15,
+                "outperformance": 2.3
+            },
+            "top_performers": get_top_performers(holdings, 5),
+            "worst_performers": get_worst_performers(holdings, 5),
+            "sector_allocation": calculate_sector_allocation(holdings),
+            "trading_summary": calculate_trading_summary(orders),
+            "generated_at": datetime.utcnow().isoformat()
+        }
+        
+        if format.lower() == "pdf":
+            # In a real implementation, you'd generate a PDF
+            return {"message": "PDF generation not implemented", "report_data": report}
+        
+        return report
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error in performance report: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=f"Invalid date format: {e}")
+    except Exception as e:
+        logger.error(f"Error generating performance report: {e}")
+        raise HTTPException(status_code=500, detail="Failed to generate performance report")
+
+@router.get("/tax-analytics")
+async def get_tax_analytics(
+    financial_year: str = Query("2024-25", description="Financial year"),
+    current_user: Dict = Depends(get_current_user)
+):
+    """Get tax analytics and optimization suggestions"""
+    try:
+        # Get holdings and calculate tax implications
+        holdings_result = await dhan_api_manager.get_holdings()
+        holdings = holdings_result.get("data", [])
+        
+        # Mock tax calculations
+        total_realized_gains = 125000  # Mock data
+        total_realized_losses = 45000
+        net_gains = total_realized_gains - total_realized_losses
+        
+        return {
+            "tax_summary": {
+                "financial_year": financial_year,
+                "total_realized_gains": total_realized_gains,
+                "total_realized_losses": total_realized_losses,
+                "net_realized_gains": net_gains,
+                "tax_liability": calculate_tax_liability(net_gains),
+                "unrealized_gains": sum(h.get("pnl", 0) for h in holdings if h.get("pnl", 0) > 0),
+                "unrealized_losses": sum(h.get("pnl", 0) for h in holdings if h.get("pnl", 0) < 0)
+            },
+            "tax_optimization": {
+                "loss_harvesting_opportunities": identify_loss_harvesting(holdings),
+                "long_term_vs_short_term": {
+                    "long_term_gains": 80000,
+                    "short_term_gains": 45000,
+                    "recommendation": "Consider holding short-term positions longer for LTCG benefits"
+                }
+            },
+            "recommendations": [
+                "Book profits in loss-making stocks before year-end",
+                "Consider SIP investments for tax-saving mutual funds",
+                "Review holding period for better tax efficiency"
+            ],
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error in tax analytics: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error generating tax analytics: {e}")
+        raise HTTPException(status_code=500, detail="Failed to generate tax analytics")
+
+# Helper functions
+def get_best_performer(holdings):
+    """Get best performing holding"""
+    if not holdings:
+        return None
+    
+    best = max(holdings, key=lambda h: h.get("pnlPercent", 0))
+    return {
+        "symbol": best.get("tradingSymbol"),
+        "pnl_percent": best.get("pnlPercent", 0),
+        "pnl_amount": best.get("pnl", 0)
+    }
+
+def get_worst_performer(holdings):
+    """Get worst performing holding"""
+    if not holdings:
+        return None
+    
+    worst = min(holdings, key=lambda h: h.get("pnlPercent", 0))
+    return {
+        "symbol": worst.get("tradingSymbol"),
+        "pnl_percent": worst.get("pnlPercent", 0),
+        "pnl_amount": worst.get("pnl", 0)
+    }
+
+def calculate_sector_allocation(holdings):
+    """Calculate sector-wise allocation"""
+    # Mock implementation
+    return {
+        "IT": 35.5,
+        "Banking": 25.2,
+        "Pharmaceuticals": 15.8,
+        "Auto": 12.3,
+        "Oil & Gas": 11.2
+    }
+
+def calculate_risk_metrics(holdings):
+    """Calculate portfolio risk metrics"""
+    return {
+        "beta": 1.15,
+        "volatility": 18.5,
+        "max_drawdown": 12.3,
+        "value_at_risk": 2.1
+    }
+
+def calculate_performance_metrics(holdings, period):
+    """Calculate performance metrics"""
+    return {
+        "absolute_return": 8.5,
+        "annualized_return": 12.8,
+        "sharpe_ratio": 1.42,
+        "alpha": 2.3
+    }
+
+def generate_monthly_performance():
+    """Generate mock monthly performance data"""
+    return [
+        {"month": "Jan", "return": 2.1},
+        {"month": "Feb", "return": -1.5},
+        {"month": "Mar", "return": 3.8},
+        {"month": "Apr", "return": 1.2},
+        {"month": "May", "return": -0.8},
+        {"month": "Jun", "return": 2.5}
+    ]
+
+def calculate_concentration_risk(holdings):
+    """Calculate portfolio concentration risk"""
+    if not holdings:
+        return 0
+    
+    total_value = sum(h.get("currentValue", 0) for h in holdings)
+    if total_value == 0:
+        return 0
+    
+    # Calculate Herfindahl index
+    weights = [h.get("currentValue", 0) / total_value for h in holdings]
+    herfindahl = sum(w * w for w in weights)
+    
+    return round(herfindahl * 100, 2)
+
+def get_top_performers(holdings, count):
+    """Get top performing holdings"""
+    sorted_holdings = sorted(holdings, key=lambda h: h.get("pnlPercent", 0), reverse=True)
+    return [
+        {
+            "symbol": h.get("tradingSymbol"),
+            "pnl_percent": h.get("pnlPercent", 0),
+            "pnl_amount": h.get("pnl", 0)
+        }
+        for h in sorted_holdings[:count]
+    ]
+
+def get_worst_performers(holdings, count):
+    """Get worst performing holdings"""
+    sorted_holdings = sorted(holdings, key=lambda h: h.get("pnlPercent", 0))
+    return [
+        {
+            "symbol": h.get("tradingSymbol"),
+            "pnl_percent": h.get("pnlPercent", 0),
+            "pnl_amount": h.get("pnl", 0)
+        }
+        for h in sorted_holdings[:count]
+    ]
+
+def calculate_trading_summary(orders):
+    """Calculate trading summary"""
+    return {
+        "total_trades": len(orders),
+        "buy_orders": len([o for o in orders if o.get("transactionType") == "BUY"]),
+        "sell_orders": len([o for o in orders if o.get("transactionType") == "SELL"]),
+        "completed_orders": len([o for o in orders if o.get("orderStatus") == "COMPLETE"]),
+        "pending_orders": len([o for o in orders if o.get("orderStatus") == "PENDING"])
+    }
+
+def calculate_tax_liability(net_gains):
+    """Calculate tax liability based on gains"""
+    if net_gains <= 100000:  # LTCG exemption limit
+        return 0
+    else:
+        # 10% LTCG tax above 1 lakh
+        return (net_gains - 100000) * 0.10
+
+def identify_loss_harvesting(holdings):
+    """Identify loss harvesting opportunities"""
+    loss_opportunities = []
+    for holding in holdings:
+        if holding.get("pnl", 0) < 0:
+            loss_opportunities.append({
+                "symbol": holding.get("tradingSymbol"),
+                "current_loss": holding.get("pnl", 0),
+                "tax_benefit": abs(holding.get("pnl", 0)) * 0.30  # Assuming 30% tax bracket
+            })
+    
+    return loss_opportunities[:5]  # Top 5 opportunities

routers/dhan.py

@@ -23,6 +23,7 @@ from models.trading import (
     HistoricalDataResponse
 )
 from services.auth import get_current_user
+from services.dhan_api_manager import dhan_api_manager, DhanAPIError
 from utils.rate_limiter import RateLimiter
 
 logger = logging.getLogger(__name__)

routers/dhan_new.py

@@ -0,0 +1,362 @@
+"""
+Updated Dhan API Router
+Handles all Dhan API operations with proper token assignment by API type
+Uses the new DhanAPIManager for different API categories
+"""
+
+from fastapi import APIRouter, HTTPException, Depends
+from typing import List, Optional, Dict, Any
+import logging
+from datetime import datetime
+
+from services.auth import get_current_user
+from services.dhan_api_manager import dhan_api_manager, DhanAPIError, DhanAPIType
+from models.trading import (
+    QuoteRequest, 
+    QuoteResponse, 
+    OrderRequest, 
+    OrderResponse,
+    HoldingsResponse,
+    PositionsResponse,
+    FundsResponse,
+    HistoricalDataRequest,
+    HistoricalDataResponse
+)
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+# ============================================================================
+# DATA API ENDPOINTS (uses DHAN_DATA_API_TOKEN)
+# ============================================================================
+
+@router.get("/securities", response_model=List[Dict[str, Any]])
+async def get_securities(
+    exchange: Optional[str] = "NSE",
+    current_user: Dict = Depends(get_current_user)
+):
+    """Get all securities/instruments using Data API"""
+    try:
+        result = await dhan_api_manager.get_security_master()
+        
+        # Filter by exchange if specified
+        if exchange and exchange != "ALL":
+            securities = result.get("data", [])
+            filtered = [s for s in securities if s.get("SEM_EXM_EXCH_ID") == exchange]
+            return filtered
+            
+        return result.get("data", [])
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error fetching securities: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error fetching securities: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch securities")
+
+@router.post("/quotes", response_model=List[QuoteResponse])
+async def get_quotes(
+    request: QuoteRequest,
+    current_user: Dict = Depends(get_current_user)
+):
+    """Get live quotes for multiple securities using Data API"""
+    try:
+        instruments = [
+            {
+                "securityId": instrument.security_id,
+                "exchangeSegment": instrument.exchange_segment
+            }
+            for instrument in request.instruments
+        ]
+        
+        result = await dhan_api_manager.get_live_feed(instruments)
+        return result.get("data", [])
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error fetching quotes: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error fetching quotes: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch quotes")
+
+@router.get("/quote/{security_id}")
+async def get_single_quote(
+    security_id: str,
+    exchange_segment: str = "NSE_EQ",
+    current_user: Dict = Depends(get_current_user)
+):
+    """Get detailed quote for a single security using Data API"""
+    try:
+        result = await dhan_api_manager.get_quote(security_id, exchange_segment)
+        return result.get("data", {})
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error fetching single quote: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error fetching single quote: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch quote")
+
+@router.post("/historical", response_model=HistoricalDataResponse)
+async def get_historical_data(
+    request: HistoricalDataRequest,
+    current_user: Dict = Depends(get_current_user)
+):
+    """Get historical data for charting using Data API"""
+    try:
+        data = {
+            "securityId": request.security_id,
+            "exchangeSegment": request.exchange_segment,
+            "instrument": request.instrument,
+            "interval": request.interval,
+            "fromDate": request.from_date,
+            "toDate": request.to_date
+        }
+        
+        result = await dhan_api_manager.get_historical_data(data)
+        return result.get("data", {})
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error fetching historical data: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error fetching historical data: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch historical data")
+
+@router.post("/intraday")
+async def get_intraday_data(
+    request: HistoricalDataRequest,
+    current_user: Dict = Depends(get_current_user)
+):
+    """Get intraday data using Data API"""
+    try:
+        data = {
+            "securityId": request.security_id,
+            "exchangeSegment": request.exchange_segment,
+            "instrument": request.instrument,
+            "interval": request.interval,
+        }
+        
+        result = await dhan_api_manager.get_intraday_data(data)
+        return result.get("data", {})
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error fetching intraday data: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error fetching intraday data: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch intraday data")
+
+@router.get("/optionchain/{underlying_security_id}")
+async def get_option_chain(
+    underlying_security_id: str,
+    exchange_segment: str = "NSE_FNO",
+    current_user: Dict = Depends(get_current_user)
+):
+    """Get option chain data using Data API"""
+    try:
+        result = await dhan_api_manager.get_option_chain(underlying_security_id, exchange_segment)
+        return result.get("data", {})
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error fetching option chain: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error fetching option chain: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch option chain")
+
+# ============================================================================
+# TRADING API ENDPOINTS (uses DHAN_TRADING_API_TOKEN or DHAN_PAPER_TRADING_TOKEN)
+# ============================================================================
+
+@router.post("/orders", response_model=OrderResponse)
+async def place_order(
+    order: OrderRequest,
+    current_user: Dict = Depends(get_current_user)
+):
+    """Place a new order using Trading API (live or paper trading based on mode)"""
+    try:
+        order_data = {
+            "securityId": order.security_id,
+            "exchangeSegment": order.exchange_segment,
+            "transactionType": order.transaction_type,
+            "quantity": order.quantity,
+            "orderType": order.order_type,
+            "productType": order.product_type,
+            "price": order.price if order.price else 0,
+            "triggerPrice": order.trigger_price if order.trigger_price else 0,
+            "validity": order.validity,
+            "disclosedQuantity": order.disclosed_quantity if order.disclosed_quantity else 0,
+            "afterMarketOrder": order.after_market_order if order.after_market_order else False
+        }
+        
+        result = await dhan_api_manager.place_order(order_data)
+        return result.get("data", {})
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error placing order: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error placing order: {e}")
+        raise HTTPException(status_code=500, detail="Failed to place order")
+
+@router.get("/orders")
+async def get_orders(current_user: Dict = Depends(get_current_user)):
+    """Get user orders using Trading API"""
+    try:
+        result = await dhan_api_manager.get_orders()
+        return {"orders": result.get("data", [])}
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error fetching orders: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error fetching orders: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch orders")
+
+@router.delete("/orders/{order_id}")
+async def cancel_order(
+    order_id: str,
+    current_user: Dict = Depends(get_current_user)
+):
+    """Cancel an order using Trading API"""
+    try:
+        result = await dhan_api_manager.cancel_order(order_id)
+        return {"message": "Order cancelled successfully", "data": result.get("data", {})}
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error cancelling order: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error cancelling order: {e}")
+        raise HTTPException(status_code=500, detail="Failed to cancel order")
+
+@router.put("/orders/{order_id}")
+async def modify_order(
+    order_id: str,
+    modifications: Dict[str, Any],
+    current_user: Dict = Depends(get_current_user)
+):
+    """Modify an existing order using Trading API"""
+    try:
+        result = await dhan_api_manager.modify_order(order_id, modifications)
+        return {"message": "Order modified successfully", "data": result.get("data", {})}
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error modifying order: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error modifying order: {e}")
+        raise HTTPException(status_code=500, detail="Failed to modify order")
+
+@router.get("/holdings", response_model=HoldingsResponse)
+async def get_holdings(current_user: Dict = Depends(get_current_user)):
+    """Get user holdings using Trading API"""
+    try:
+        result = await dhan_api_manager.get_holdings()
+        return {"holdings": result.get("data", [])}
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error fetching holdings: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error fetching holdings: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch holdings")
+
+@router.get("/positions", response_model=PositionsResponse)
+async def get_positions(current_user: Dict = Depends(get_current_user)):
+    """Get user positions using Trading API"""
+    try:
+        result = await dhan_api_manager.get_positions()
+        return {"positions": result.get("data", [])}
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error fetching positions: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error fetching positions: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch positions")
+
+@router.get("/funds", response_model=FundsResponse)
+async def get_funds(current_user: Dict = Depends(get_current_user)):
+    """Get user funds and margin using Trading API"""
+    try:
+        result = await dhan_api_manager.get_funds()
+        return result.get("data", {})
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error fetching funds: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error fetching funds: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch funds")
+
+# ============================================================================
+# CONFIGURATION AND STATUS ENDPOINTS
+# ============================================================================
+
+@router.get("/config")
+async def get_api_config(current_user: Dict = Depends(get_current_user)):
+    """Get current API configuration and mode"""
+    try:
+        return {
+            "trading_mode": dhan_api_manager.get_current_mode(),
+            "is_paper_trading": dhan_api_manager.is_paper_trading(),
+            "base_url": dhan_api_manager.base_url,
+            "client_id": dhan_api_manager.get_client_id_for_api_type(
+                DhanAPIType.PAPER_TRADING if dhan_api_manager.is_paper_trading() else DhanAPIType.TRADING
+            ),
+            "websocket_credentials": dhan_api_manager.get_websocket_credentials(),
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    except Exception as e:
+        logger.error(f"Error fetching API config: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch API configuration")
+
+@router.get("/market-status")
+async def get_market_status(current_user: Dict = Depends(get_current_user)):
+    """Get current market status"""
+    try:
+        # This endpoint might not exist in Dhan API, so we'll create a mock response
+        # based on time and market hours
+        now = datetime.now()
+        is_weekend = now.weekday() >= 5  # Saturday = 5, Sunday = 6
+        
+        # NSE trading hours: 9:15 AM to 3:30 PM
+        market_open_time = now.replace(hour=9, minute=15, second=0, microsecond=0)
+        market_close_time = now.replace(hour=15, minute=30, second=0, microsecond=0)
+        
+        is_market_hours = market_open_time <= now <= market_close_time and not is_weekend
+        
+        return {
+            "market_status": "OPEN" if is_market_hours else "CLOSED",
+            "timestamp": now.isoformat(),
+            "next_open": market_open_time.isoformat() if not is_market_hours else None,
+            "next_close": market_close_time.isoformat() if is_market_hours else None,
+            "trading_mode": dhan_api_manager.get_current_mode()
+        }
+        
+    except Exception as e:
+        logger.error(f"Error getting market status: {e}")
+        raise HTTPException(status_code=500, detail="Failed to get market status")
+
+@router.post("/switch-mode")
+async def switch_trading_mode(
+    mode: str,
+    current_user: Dict = Depends(get_current_user)
+):
+    """Switch between live and paper trading modes (requires restart)"""
+    try:
+        if mode not in ["live", "paper"]:
+            raise HTTPException(status_code=400, detail="Mode must be 'live' or 'paper'")
+        
+        return {
+            "message": f"Trading mode switch to '{mode}' requested. Please restart the application to apply changes.",
+            "current_mode": dhan_api_manager.get_current_mode(),
+            "requested_mode": mode,
+            "note": "This requires updating the DHAN_TRADING_MODE environment variable"
+        }
+        
+    except Exception as e:
+        logger.error(f"Error switching trading mode: {e}")
+        raise HTTPException(status_code=500, detail="Failed to switch trading mode")

routers/screener.py

@@ -0,0 +1,402 @@
+"""
+Market Screener Router
+Handles stock screening, filtering, and discovery
+"""
+
+from fastapi import APIRouter, HTTPException, Depends, Query
+from typing import List, Dict, Any, Optional
+import logging
+from datetime import datetime, timedelta
+
+from config.settings import get_settings
+from services.auth import get_current_user
+from services.dhan_api_manager import dhan_api_manager, DhanAPIError
+from models.trading import ExchangeSegment
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+settings = get_settings()
+
+@router.get("/stocks")
+async def screen_stocks(
+    exchange: str = Query("NSE", description="Exchange segment"),
+    market_cap_min: Optional[float] = Query(None, description="Minimum market cap"),
+    market_cap_max: Optional[float] = Query(None, description="Maximum market cap"),
+    price_min: Optional[float] = Query(None, description="Minimum price"),
+    price_max: Optional[float] = Query(None, description="Maximum price"),
+    volume_min: Optional[int] = Query(None, description="Minimum volume"),
+    pe_ratio_min: Optional[float] = Query(None, description="Minimum P/E ratio"),
+    pe_ratio_max: Optional[float] = Query(None, description="Maximum P/E ratio"),
+    sector: Optional[str] = Query(None, description="Sector filter"),
+    limit: int = Query(50, description="Maximum results to return"),
+    current_user: Dict = Depends(get_current_user)
+):
+    """Screen stocks based on various criteria"""
+    try:
+        # Get securities from Dhan API
+        securities_result = await dhan_api_manager.get_security_master()
+        securities = securities_result.get("data", [])
+        
+        # Filter by exchange
+        if exchange != "ALL":
+            securities = [s for s in securities if s.get("SEM_EXM_EXCH_ID") == exchange]
+        
+        # Apply filters (this is a simplified implementation)
+        # In a production system, you'd want to get live market data for each security
+        filtered_securities = []
+        
+        for security in securities[:limit]:  # Limit initial processing
+            try:
+                # Basic filtering based on security master data
+                if security.get("SEM_INSTRUMENT_NAME") == "EQUITY":
+                    security_data = {
+                        "security_id": security.get("SEM_SMST_SECURITY_ID"),
+                        "symbol": security.get("SEM_TRADING_SYMBOL"),
+                        "instrument_name": security.get("SEM_INSTRUMENT_NAME"),
+                        "exchange": security.get("SEM_EXM_EXCH_ID"),
+                        "lot_size": security.get("SEM_LOT_UNITS", 1),
+                        "tick_size": security.get("SEM_TICK_SIZE"),
+                        "series": security.get("SEM_SERIES"),
+                        "custom_symbol": security.get("SEM_CUSTOM_SYMBOL")
+                    }
+                    
+                    # Add to results if it passes basic criteria
+                    if security_data["symbol"]:
+                        filtered_securities.append(security_data)
+                        
+            except Exception as e:
+                logger.warning(f"Error processing security {security}: {e}")
+                continue
+        
+        return {
+            "securities": filtered_securities[:limit],
+            "total_count": len(filtered_securities),
+            "filters_applied": {
+                "exchange": exchange,
+                "market_cap_min": market_cap_min,
+                "market_cap_max": market_cap_max,
+                "price_min": price_min,
+                "price_max": price_max,
+                "volume_min": volume_min,
+                "pe_ratio_min": pe_ratio_min,
+                "pe_ratio_max": pe_ratio_max,
+                "sector": sector
+            },
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error in stock screening: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error screening stocks: {e}")
+        raise HTTPException(status_code=500, detail="Failed to screen stocks")
+
+@router.get("/top-gainers")
+async def get_top_gainers(
+    exchange: str = Query("NSE_EQ", description="Exchange segment"),
+    limit: int = Query(20, description="Number of top gainers to return"),
+    current_user: Dict = Depends(get_current_user)
+):
+    """Get top gaining stocks"""
+    try:
+        # This is a mock implementation
+        # In a real system, you'd fetch live market data and sort by gains
+        mock_gainers = [
+            {
+                "symbol": "RELIANCE",
+                "security_id": "2885",
+                "exchange_segment": "NSE_EQ",
+                "ltp": 2650.0,
+                "change": 45.50,
+                "change_percent": 1.75,
+                "volume": 2500000
+            },
+            {
+                "symbol": "TCS",
+                "security_id": "11723", 
+                "exchange_segment": "NSE_EQ",
+                "ltp": 3890.0,
+                "change": 55.25,
+                "change_percent": 1.44,
+                "volume": 1800000
+            }
+        ]
+        
+        return {
+            "top_gainers": mock_gainers[:limit],
+            "exchange": exchange,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+    except Exception as e:
+        logger.error(f"Error fetching top gainers: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch top gainers")
+
+@router.get("/top-losers")
+async def get_top_losers(
+    exchange: str = Query("NSE_EQ", description="Exchange segment"),
+    limit: int = Query(20, description="Number of top losers to return"),
+    current_user: Dict = Depends(get_current_user)
+):
+    """Get top losing stocks"""
+    try:
+        # This is a mock implementation
+        mock_losers = [
+            {
+                "symbol": "HDFC",
+                "security_id": "1333",
+                "exchange_segment": "NSE_EQ", 
+                "ltp": 1580.0,
+                "change": -25.75,
+                "change_percent": -1.60,
+                "volume": 3200000
+            },
+            {
+                "symbol": "INFY",
+                "security_id": "1594",
+                "exchange_segment": "NSE_EQ",
+                "ltp": 1685.0,
+                "change": -18.50,
+                "change_percent": -1.09,
+                "volume": 2100000
+            }
+        ]
+        
+        return {
+            "top_losers": mock_losers[:limit],
+            "exchange": exchange,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+    except Exception as e:
+        logger.error(f"Error fetching top losers: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch top losers")
+
+@router.get("/most-active")
+async def get_most_active(
+    exchange: str = Query("NSE_EQ", description="Exchange segment"),
+    limit: int = Query(20, description="Number of most active stocks to return"),
+    current_user: Dict = Depends(get_current_user)
+):
+    """Get most active stocks by volume"""
+    try:
+        # This is a mock implementation
+        mock_active = [
+            {
+                "symbol": "RELIANCE",
+                "security_id": "2885",
+                "exchange_segment": "NSE_EQ",
+                "ltp": 2650.0,
+                "volume": 5500000,
+                "value": 14575000000,
+                "change_percent": 1.75
+            },
+            {
+                "symbol": "HDFC",
+                "security_id": "1333", 
+                "exchange_segment": "NSE_EQ",
+                "ltp": 1580.0,
+                "volume": 4200000,
+                "value": 6636000000,
+                "change_percent": -1.60
+            }
+        ]
+        
+        return {
+            "most_active": mock_active[:limit],
+            "exchange": exchange,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+    except Exception as e:
+        logger.error(f"Error fetching most active stocks: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch most active stocks")
+
+@router.get("/technical-scan")
+async def technical_scan(
+    pattern: str = Query("bullish_engulfing", description="Technical pattern to scan"),
+    exchange: str = Query("NSE_EQ", description="Exchange segment"),
+    timeframe: str = Query("1D", description="Timeframe for analysis"),
+    limit: int = Query(50, description="Maximum results"),
+    current_user: Dict = Depends(get_current_user)
+):
+    """Scan stocks based on technical patterns"""
+    try:
+        # This is a mock implementation
+        # In a real system, you'd analyze historical data for technical patterns
+        mock_results = [
+            {
+                "symbol": "TCS",
+                "security_id": "11723",
+                "exchange_segment": "NSE_EQ",
+                "pattern": pattern,
+                "confidence": 0.85,
+                "ltp": 3890.0,
+                "signal": "BUY",
+                "target": 4100.0,
+                "stop_loss": 3750.0
+            },
+            {
+                "symbol": "INFY", 
+                "security_id": "1594",
+                "exchange_segment": "NSE_EQ",
+                "pattern": pattern,
+                "confidence": 0.78,
+                "ltp": 1685.0,
+                "signal": "BUY",
+                "target": 1780.0,
+                "stop_loss": 1620.0
+            }
+        ]
+        
+        return {
+            "scan_results": mock_results[:limit],
+            "pattern": pattern,
+            "exchange": exchange,
+            "timeframe": timeframe,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+    except Exception as e:
+        logger.error(f"Error in technical scan: {e}")
+        raise HTTPException(status_code=500, detail="Failed to perform technical scan")
+
+@router.get("/sector-performance")
+async def get_sector_performance(
+    current_user: Dict = Depends(get_current_user)
+):
+    """Get sector-wise performance"""
+    try:
+        # This is a mock implementation
+        mock_sectors = [
+            {
+                "sector": "Information Technology",
+                "change_percent": 2.15,
+                "market_cap": 12500000000000,
+                "top_stocks": ["TCS", "INFY", "WIPRO"],
+                "stocks_advanced": 15,
+                "stocks_declined": 5
+            },
+            {
+                "sector": "Banking",
+                "change_percent": -0.85,
+                "market_cap": 8900000000000,
+                "top_stocks": ["HDFC", "ICICI", "SBI"],
+                "stocks_advanced": 8,
+                "stocks_declined": 12
+            },
+            {
+                "sector": "Oil & Gas",
+                "change_percent": 1.65,
+                "market_cap": 6700000000000,
+                "top_stocks": ["RELIANCE", "ONGC", "IOC"],
+                "stocks_advanced": 12,
+                "stocks_declined": 8
+            }
+        ]
+        
+        return {
+            "sector_performance": mock_sectors,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+    except Exception as e:
+        logger.error(f"Error fetching sector performance: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch sector performance")
+
+@router.get("/custom-scan")
+async def custom_scan(
+    criteria: str = Query(..., description="Custom scan criteria as JSON string"),
+    current_user: Dict = Depends(get_current_user)
+):
+    """Run custom stock scan with user-defined criteria"""
+    try:
+        import json
+        
+        # Parse criteria
+        try:
+            scan_criteria = json.loads(criteria)
+        except json.JSONDecodeError:
+            raise HTTPException(status_code=400, detail="Invalid criteria format")
+        
+        # This is a mock implementation
+        # In a real system, you'd apply the custom criteria to screen stocks
+        mock_results = [
+            {
+                "symbol": "RELIANCE",
+                "security_id": "2885",
+                "exchange_segment": "NSE_EQ",
+                "matches": ["price_above_sma_50", "rsi_oversold"],
+                "score": 0.82
+            }
+        ]
+        
+        return {
+            "scan_results": mock_results,
+            "criteria": scan_criteria,
+            "total_matches": len(mock_results),
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in custom scan: {e}")
+        raise HTTPException(status_code=500, detail="Failed to run custom scan")
+
+@router.get("/search")
+async def search_securities(
+    query: str = Query(..., description="Search query"),
+    exchange: Optional[str] = Query(None, description="Exchange filter"),
+    instrument_type: Optional[str] = Query(None, description="Instrument type filter"),
+    limit: int = Query(20, description="Maximum results"),
+    current_user: Dict = Depends(get_current_user)
+):
+    """Search securities by symbol or name"""
+    try:
+        # Get securities from Dhan API
+        securities_result = await dhan_api_manager.get_security_master()
+        securities = securities_result.get("data", [])
+        
+        # Filter and search
+        query_lower = query.lower()
+        matching_securities = []
+        
+        for security in securities:
+            symbol = security.get("SEM_TRADING_SYMBOL", "").lower()
+            custom_symbol = security.get("SEM_CUSTOM_SYMBOL", "").lower()
+            
+            if (query_lower in symbol or query_lower in custom_symbol):
+                # Apply additional filters
+                if exchange and security.get("SEM_EXM_EXCH_ID") != exchange:
+                    continue
+                if instrument_type and security.get("SEM_INSTRUMENT_NAME") != instrument_type:
+                    continue
+                
+                matching_securities.append({
+                    "security_id": security.get("SEM_SMST_SECURITY_ID"),
+                    "symbol": security.get("SEM_TRADING_SYMBOL"),
+                    "instrument_name": security.get("SEM_INSTRUMENT_NAME"),
+                    "exchange": security.get("SEM_EXM_EXCH_ID"),
+                    "custom_symbol": security.get("SEM_CUSTOM_SYMBOL"),
+                    "series": security.get("SEM_SERIES"),
+                    "lot_size": security.get("SEM_LOT_UNITS", 1)
+                })
+                
+                if len(matching_securities) >= limit:
+                    break
+        
+        return {
+            "results": matching_securities,
+            "query": query,
+            "total_found": len(matching_securities),
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+    except DhanAPIError as e:
+        logger.error(f"Dhan API error in search: {e}")
+        raise HTTPException(status_code=e.status_code or 500, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error searching securities: {e}")
+        raise HTTPException(status_code=500, detail="Failed to search securities")

services/ai_engine.py

@@ -0,0 +1,520 @@
+"""
+AI Engine Service
+Handles AI-powered trading signal generation, market analysis, and ML models
+"""
+
+import logging
+from typing import Dict, List, Any, Optional
+from datetime import datetime, timedelta
+import asyncio
+import random
+
+from models.signals import (
+    SignalResponse, SignalType, SignalStrength, TimeFrame, 
+    TechnicalIndicator, FundamentalMetric, SentimentIndicator, 
+    AISignal, MarketAnalysisResponse, BacktestResult
+)
+
+logger = logging.getLogger(__name__)
+
+class AIEngine:
+    """Service for AI-powered trading analysis and signal generation"""
+    
+    def __init__(self):
+        self.models = {
+            "technical_model": {"accuracy": 0.72, "confidence": 0.85},
+            "fundamental_model": {"accuracy": 0.68, "confidence": 0.78},
+            "sentiment_model": {"accuracy": 0.65, "confidence": 0.70},
+            "ensemble_model": {"accuracy": 0.76, "confidence": 0.82}
+        }
+    
+    async def generate_trading_signals(
+        self, 
+        market_data: List[Dict[str, Any]], 
+        user_preferences: Optional[Dict[str, Any]] = None
+    ) -> List[SignalResponse]:
+        """Generate AI trading signals for given market data"""
+        try:
+            signals = []
+            
+            for data in market_data:
+                signal = await self._generate_single_signal(data, user_preferences)
+                if signal:
+                    signals.append(signal)
+            
+            return signals
+            
+        except Exception as e:
+            logger.error(f"Error generating trading signals: {e}")
+            raise
+    
+    async def _generate_single_signal(
+        self, 
+        market_data: Dict[str, Any], 
+        user_preferences: Optional[Dict[str, Any]] = None
+    ) -> Optional[SignalResponse]:
+        """Generate a single trading signal"""
+        try:
+            symbol = market_data.get("symbol", "UNKNOWN")
+            current_price = market_data.get("ltp", 0)
+            
+            # Technical Analysis
+            technical_indicators = self._analyze_technical_indicators(market_data)
+            
+            # Fundamental Analysis
+            fundamental_metrics = self._analyze_fundamentals(market_data)
+            
+            # Sentiment Analysis
+            sentiment_indicators = self._analyze_sentiment(symbol)
+            
+            # AI Model Predictions
+            ai_predictions = self._run_ai_models(market_data)
+            
+            # Combine all analyses to generate final signal
+            final_signal = self._combine_analyses(
+                technical_indicators, fundamental_metrics, 
+                sentiment_indicators, ai_predictions
+            )
+            
+            if not final_signal:
+                return None
+            
+            # Calculate target and stop loss
+            target_price, stop_loss = self._calculate_price_targets(
+                current_price, final_signal["signal_type"], final_signal["strength"]
+            )
+            
+            return SignalResponse(
+                signal_id=f"SIG_{symbol}_{int(datetime.utcnow().timestamp())}",
+                security_id=market_data.get("security_id", ""),
+                symbol=symbol,
+                exchange_segment=market_data.get("exchange_segment", "NSE_EQ"),
+                signal_type=final_signal["signal_type"],
+                signal_strength=final_signal["strength"],
+                confidence_score=final_signal["confidence"],
+                time_frame=TimeFrame.SHORT_TERM,
+                current_price=current_price,
+                target_price=target_price,
+                stop_loss=stop_loss,
+                technical_analysis=technical_indicators,
+                fundamental_analysis=fundamental_metrics,
+                sentiment_analysis=sentiment_indicators,
+                ai_analysis=ai_predictions,
+                risk_rating=self._calculate_risk_rating(final_signal["confidence"]),
+                expected_return=self._calculate_expected_return(current_price, target_price),
+                probability_of_success=final_signal["confidence"],
+                market_condition="bullish",  # Mock
+                generated_at=datetime.utcnow(),
+                valid_until=datetime.utcnow() + timedelta(days=7),
+                summary=self._generate_signal_summary(final_signal, symbol),
+                reasoning=self._generate_reasoning(technical_indicators, fundamental_metrics),
+                key_catalysts=self._identify_key_catalysts(symbol)
+            )
+            
+        except Exception as e:
+            logger.error(f"Error generating signal for {symbol}: {e}")
+            return None
+    
+    def _analyze_technical_indicators(self, market_data: Dict[str, Any]) -> List[TechnicalIndicator]:
+        """Analyze technical indicators"""
+        indicators = []
+        
+        # Mock RSI analysis
+        rsi_value = random.uniform(30, 70)
+        rsi_signal = SignalType.BUY if rsi_value < 40 else SignalType.SELL if rsi_value > 60 else SignalType.HOLD
+        rsi_strength = SignalStrength.STRONG if abs(rsi_value - 50) > 20 else SignalStrength.MODERATE
+        
+        indicators.append(TechnicalIndicator(
+            name="RSI",
+            value=rsi_value,
+            signal=rsi_signal,
+            strength=rsi_strength,
+            description=f"RSI at {rsi_value:.1f} indicates {'oversold' if rsi_value < 40 else 'overbought' if rsi_value > 60 else 'neutral'} conditions"
+        ))
+        
+        # Mock MACD analysis
+        macd_value = random.uniform(-5, 5)
+        macd_signal = SignalType.BUY if macd_value > 0 else SignalType.SELL
+        macd_strength = SignalStrength.STRONG if abs(macd_value) > 3 else SignalStrength.MODERATE
+        
+        indicators.append(TechnicalIndicator(
+            name="MACD",
+            value=macd_value,
+            signal=macd_signal,
+            strength=macd_strength,
+            description=f"MACD at {macd_value:.2f} shows {'bullish' if macd_value > 0 else 'bearish'} momentum"
+        ))
+        
+        # Mock Moving Average analysis
+        ma_signal = random.choice([SignalType.BUY, SignalType.SELL, SignalType.HOLD])
+        ma_strength = random.choice([SignalStrength.WEAK, SignalStrength.MODERATE, SignalStrength.STRONG])
+        
+        indicators.append(TechnicalIndicator(
+            name="SMA_50",
+            value=market_data.get("ltp", 0) * random.uniform(0.95, 1.05),
+            signal=ma_signal,
+            strength=ma_strength,
+            description="Price action relative to 50-day moving average"
+        ))
+        
+        return indicators
+    
+    def _analyze_fundamentals(self, market_data: Dict[str, Any]) -> List[FundamentalMetric]:
+        """Analyze fundamental metrics"""
+        metrics = []
+        
+        # Mock P/E ratio analysis
+        pe_ratio = random.uniform(15, 35)
+        metrics.append(FundamentalMetric(
+            metric_name="P/E Ratio",
+            current_value=pe_ratio,
+            industry_average=22.5,
+            percentile_rank=random.uniform(0.2, 0.8),
+            trend="improving" if pe_ratio < 25 else "deteriorating",
+            impact="positive" if pe_ratio < 20 else "negative"
+        ))
+        
+        # Mock ROE analysis
+        roe = random.uniform(10, 25)
+        metrics.append(FundamentalMetric(
+            metric_name="ROE",
+            current_value=roe,
+            industry_average=18.0,
+            percentile_rank=random.uniform(0.3, 0.9),
+            trend="stable",
+            impact="positive" if roe > 15 else "neutral"
+        ))
+        
+        return metrics
+    
+    def _analyze_sentiment(self, symbol: str) -> List[SentimentIndicator]:
+        """Analyze market sentiment"""
+        indicators = []
+        
+        # Mock news sentiment
+        news_score = random.uniform(-0.5, 0.8)
+        indicators.append(SentimentIndicator(
+            source="News Analysis",
+            score=news_score,
+            confidence=random.uniform(0.6, 0.9),
+            key_factors=["earnings report", "sector outlook", "market conditions"],
+            news_count=random.randint(10, 50)
+        ))
+        
+        # Mock social media sentiment
+        social_score = random.uniform(-0.3, 0.6)
+        indicators.append(SentimentIndicator(
+            source="Social Media",
+            score=social_score,
+            confidence=random.uniform(0.5, 0.8),
+            key_factors=["trader discussions", "volume alerts", "price action"],
+            news_count=random.randint(100, 500)
+        ))
+        
+        return indicators
+    
+    def _run_ai_models(self, market_data: Dict[str, Any]) -> List[AISignal]:
+        """Run AI/ML models for predictions"""
+        predictions = []
+        
+        for model_name, model_info in self.models.items():
+            prediction = random.choice([SignalType.BUY, SignalType.SELL, SignalType.HOLD])
+            confidence = random.uniform(0.6, model_info["confidence"])
+            
+            predictions.append(AISignal(
+                model_name=model_name,
+                prediction=prediction,
+                confidence_score=confidence,
+                feature_importance={
+                    "price_momentum": random.uniform(0.1, 0.3),
+                    "volume_profile": random.uniform(0.1, 0.3),
+                    "market_correlation": random.uniform(0.1, 0.3),
+                    "volatility": random.uniform(0.1, 0.3)
+                },
+                prediction_horizon="5-7 days"
+            ))
+        
+        return predictions
+    
+    def _combine_analyses(
+        self, 
+        technical: List[TechnicalIndicator],
+        fundamental: List[FundamentalMetric], 
+        sentiment: List[SentimentIndicator],
+        ai_predictions: List[AISignal]
+    ) -> Optional[Dict[str, Any]]:
+        """Combine all analyses to generate final signal"""
+        
+        # Weight different analysis types
+        weights = {
+            "technical": 0.4,
+            "fundamental": 0.3,
+            "sentiment": 0.1,
+            "ai": 0.2
+        }
+        
+        # Calculate weighted scores for each signal type
+        buy_score = 0
+        sell_score = 0
+        hold_score = 0
+        
+        # Technical indicators
+        for indicator in technical:
+            score = 1.0 if indicator.strength == SignalStrength.STRONG else 0.7 if indicator.strength == SignalStrength.MODERATE else 0.3
+            if indicator.signal == SignalType.BUY:
+                buy_score += score * weights["technical"] / len(technical)
+            elif indicator.signal == SignalType.SELL:
+                sell_score += score * weights["technical"] / len(technical)
+            else:
+                hold_score += score * weights["technical"] / len(technical)
+        
+        # AI predictions
+        for prediction in ai_predictions:
+            score = prediction.confidence_score
+            if prediction.prediction == SignalType.BUY:
+                buy_score += score * weights["ai"] / len(ai_predictions)
+            elif prediction.prediction == SignalType.SELL:
+                sell_score += score * weights["ai"] / len(ai_predictions)
+            else:
+                hold_score += score * weights["ai"] / len(ai_predictions)
+        
+        # Sentiment analysis
+        avg_sentiment = sum(s.score for s in sentiment) / len(sentiment) if sentiment else 0
+        if avg_sentiment > 0.2:
+            buy_score += weights["sentiment"]
+        elif avg_sentiment < -0.2:
+            sell_score += weights["sentiment"]
+        else:
+            hold_score += weights["sentiment"]
+        
+        # Fundamental contribution (simplified)
+        buy_score += weights["fundamental"] * 0.5  # Mock positive fundamentals
+        
+        # Determine final signal
+        max_score = max(buy_score, sell_score, hold_score)
+        
+        if max_score < 0.4:  # Threshold for signal generation
+            return None
+        
+        if buy_score == max_score:
+            signal_type = SignalType.STRONG_BUY if max_score > 0.8 else SignalType.BUY
+        elif sell_score == max_score:
+            signal_type = SignalType.STRONG_SELL if max_score > 0.8 else SignalType.SELL
+        else:
+            signal_type = SignalType.HOLD
+        
+        strength = SignalStrength.STRONG if max_score > 0.8 else SignalStrength.MODERATE if max_score > 0.6 else SignalStrength.WEAK
+        
+        return {
+            "signal_type": signal_type,
+            "strength": strength,
+            "confidence": max_score
+        }
+    
+    def _calculate_price_targets(self, current_price: float, signal_type: SignalType, strength: SignalStrength) -> tuple:
+        """Calculate target price and stop loss"""
+        if signal_type in [SignalType.BUY, SignalType.STRONG_BUY]:
+            target_multiplier = 1.08 if strength == SignalStrength.STRONG else 1.05
+            stop_multiplier = 0.95 if strength == SignalStrength.STRONG else 0.97
+            
+            target_price = current_price * target_multiplier
+            stop_loss = current_price * stop_multiplier
+        elif signal_type in [SignalType.SELL, SignalType.STRONG_SELL]:
+            target_multiplier = 0.92 if strength == SignalStrength.STRONG else 0.95
+            stop_multiplier = 1.05 if strength == SignalStrength.STRONG else 1.03
+            
+            target_price = current_price * target_multiplier
+            stop_loss = current_price * stop_multiplier
+        else:
+            target_price = None
+            stop_loss = None
+        
+        return target_price, stop_loss
+    
+    def _calculate_risk_rating(self, confidence: float) -> str:
+        """Calculate risk rating based on confidence"""
+        if confidence > 0.8:
+            return "Low"
+        elif confidence > 0.6:
+            return "Medium"
+        else:
+            return "High"
+    
+    def _calculate_expected_return(self, current_price: float, target_price: Optional[float]) -> Optional[float]:
+        """Calculate expected return percentage"""
+        if target_price and current_price:
+            return round(((target_price - current_price) / current_price) * 100, 2)
+        return None
+    
+    def _generate_signal_summary(self, signal: Dict[str, Any], symbol: str) -> str:
+        """Generate human-readable signal summary"""
+        signal_type = signal["signal_type"]
+        strength = signal["strength"]
+        
+        if signal_type in [SignalType.BUY, SignalType.STRONG_BUY]:
+            return f"{strength.value.title()} BUY signal for {symbol} based on positive technical and AI analysis"
+        elif signal_type in [SignalType.SELL, SignalType.STRONG_SELL]:
+            return f"{strength.value.title()} SELL signal for {symbol} due to bearish indicators"
+        else:
+            return f"HOLD recommendation for {symbol} with mixed signals"
+    
+    def _generate_reasoning(self, technical: List[TechnicalIndicator], fundamental: List[FundamentalMetric]) -> str:
+        """Generate detailed reasoning"""
+        reasons = []
+        
+        # Technical reasons
+        for indicator in technical:
+            if indicator.signal != SignalType.HOLD:
+                reasons.append(f"{indicator.name} shows {indicator.signal.value.lower()} signal")
+        
+        # Fundamental reasons
+        for metric in fundamental:
+            if metric.impact == "positive":
+                reasons.append(f"{metric.metric_name} is favorable")
+        
+        return ". ".join(reasons[:3]) + "."
+    
+    def _identify_key_catalysts(self, symbol: str) -> List[str]:
+        """Identify key catalysts for the signal"""
+        catalysts = [
+            "Strong quarterly earnings",
+            "Positive sector outlook", 
+            "Technical breakout pattern",
+            "Improved fundamentals",
+            "Market momentum"
+        ]
+        
+        return random.sample(catalysts, random.randint(2, 4))
+    
+    async def generate_market_analysis(self) -> MarketAnalysisResponse:
+        """Generate comprehensive market analysis"""
+        try:
+            # This would typically involve complex market analysis
+            # For now, returning mock data
+            
+            return MarketAnalysisResponse(
+                overall_market_sentiment="Bullish",
+                market_trend={
+                    "trend_direction": "Upward",
+                    "trend_strength": SignalStrength.MODERATE,
+                    "support_levels": [21800, 21600, 21400],
+                    "resistance_levels": [22200, 22400, 22600],
+                    "trend_duration": 15
+                },
+                volatility_index=18.5,
+                fear_greed_index=65,
+                sector_analysis=[
+                    {
+                        "sector_name": "Information Technology",
+                        "performance": 2.1,
+                        "outlook": "Positive",
+                        "key_drivers": ["Strong earnings", "Export growth"],
+                        "top_stocks": ["TCS", "INFY", "WIPRO"],
+                        "recommendation": SignalType.BUY
+                    }
+                ],
+                macro_factors=["GDP growth", "Inflation control", "FII inflows"],
+                market_events=["Q4 earnings season", "Budget announcements"],
+                generated_at=datetime.utcnow()
+            )
+            
+        except Exception as e:
+            logger.error(f"Error generating market analysis: {e}")
+            raise
+    
+    async def run_backtesting(self, symbols: List[str], period: str, strategy_config: Dict[str, Any]) -> BacktestResult:
+        """Run backtesting on trading strategies"""
+        try:
+            # Mock backtesting results
+            total_signals = random.randint(50, 200)
+            successful_signals = int(total_signals * random.uniform(0.6, 0.8))
+            
+            return BacktestResult(
+                start_date=datetime.utcnow() - timedelta(days=365),
+                end_date=datetime.utcnow(),
+                total_signals=total_signals,
+                successful_signals=successful_signals,
+                accuracy_rate=successful_signals / total_signals,
+                total_return=random.uniform(8, 25),
+                annualized_return=random.uniform(12, 18),
+                max_drawdown=random.uniform(8, 15),
+                sharpe_ratio=random.uniform(1.2, 2.1),
+                win_rate=random.uniform(60, 75),
+                average_win=random.uniform(3, 8),
+                average_loss=random.uniform(-2, -5),
+                profit_factor=random.uniform(1.5, 2.5)
+            )
+            
+        except Exception as e:
+            logger.error(f"Error running backtesting: {e}")
+            raise
+    
+    async def analyze_stock_sentiment(self, symbol: str) -> Dict[str, Any]:
+        """Analyze sentiment for a specific stock"""
+        try:
+            # Mock sentiment analysis
+            sentiment_score = random.uniform(-0.5, 0.8)
+            
+            if sentiment_score > 0.5:
+                label = "Very Positive"
+            elif sentiment_score > 0.2:
+                label = "Positive"
+            elif sentiment_score > -0.2:
+                label = "Neutral"
+            elif sentiment_score > -0.5:
+                label = "Negative"
+            else:
+                label = "Very Negative"
+            
+            return {
+                "score": sentiment_score,
+                "label": label,
+                "confidence": random.uniform(0.7, 0.95),
+                "factors": ["earnings report", "analyst upgrades", "sector performance"],
+                "news_summary": f"Recent news about {symbol} has been generally {label.lower()}"
+            }
+            
+        except Exception as e:
+            logger.error(f"Error analyzing sentiment for {symbol}: {e}")
+            raise
+    
+    async def get_available_strategies(self) -> List[Dict[str, Any]]:
+        """Get list of available AI trading strategies"""
+        return [
+            {
+                "id": "momentum_strategy",
+                "name": "Momentum Trading",
+                "description": "Identifies stocks with strong price momentum",
+                "accuracy": 72.5,
+                "risk_level": "Medium"
+            },
+            {
+                "id": "mean_reversion",
+                "name": "Mean Reversion",
+                "description": "Identifies oversold/overbought conditions",
+                "accuracy": 68.3,
+                "risk_level": "Low"
+            },
+            {
+                "id": "breakout_strategy",
+                "name": "Breakout Detection",
+                "description": "Identifies technical breakout patterns",
+                "accuracy": 75.1,
+                "risk_level": "Medium-High"
+            }
+        ]
+    
+    async def create_custom_strategy(self, user_id: str, config: Dict[str, Any]) -> str:
+        """Create a custom AI trading strategy"""
+        try:
+            # In a real implementation, would train/configure the strategy
+            strategy_id = f"custom_{user_id}_{int(datetime.utcnow().timestamp())}"
+            
+            # Mock strategy creation
+            logger.info(f"Created custom strategy {strategy_id} for user {user_id}")
+            
+            return strategy_id
+            
+        except Exception as e:
+            logger.error(f"Error creating custom strategy: {e}")
+            raise

services/dhan_api_manager.py

@@ -0,0 +1,258 @@
+"""
+Dhan API Manager
+Centralized management for different Dhan API types and tokens
+Handles Trading API, Data API, and Paper Trading API calls
+"""
+
+from typing import Dict, Any, Optional, Literal
+from enum import Enum
+import httpx
+import logging
+from datetime import datetime
+
+from config.settings import get_settings
+
+logger = logging.getLogger(__name__)
+settings = get_settings()
+
+
+class DhanAPIType(Enum):
+    """Types of Dhan APIs"""
+    TRADING = "trading"        # Order management, portfolio, funds
+    DATA = "data"             # Market data, quotes, historical data
+    PAPER_TRADING = "paper"   # Sandbox/paper trading
+
+
+class DhanAPIError(Exception):
+    """Custom exception for Dhan API errors"""
+    def __init__(self, message: str, status_code: Optional[int] = None, response_data: Optional[Dict] = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response_data = response_data
+
+
+class DhanAPIManager:
+    """Centralized manager for all Dhan API interactions"""
+    
+    def __init__(self):
+        self.settings = settings
+        self.base_url = settings.DHAN_API_BASE_URL
+        
+        # API endpoint mappings by type
+        self.api_endpoints = {
+            # Trading API endpoints
+            DhanAPIType.TRADING: {
+                "orders": "/orders",
+                "positions": "/positions", 
+                "holdings": "/holdings",
+                "funds": "/funds",
+                "margin": "/margin",
+                "ledger": "/ledger",
+                "statements": "/statements",
+            },
+            
+            # Data API endpoints
+            DhanAPIType.DATA: {
+                "securitymaster": "/securitymaster",
+                "marketfeed": "/marketfeed",
+                "quotes": "/marketfeed/quote",
+                "ltp": "/marketfeed/ltp",
+                "ohlc": "/marketfeed/ohlc",
+                "historical": "/charts/historical",
+                "intraday": "/charts/intraday",
+                "optionchain": "/optionchain",
+            },
+            
+            # Paper Trading endpoints (same as trading but with different token)
+            DhanAPIType.PAPER_TRADING: {
+                "orders": "/orders",
+                "positions": "/positions",
+                "holdings": "/holdings", 
+                "funds": "/funds",
+                "margin": "/margin",
+            }
+        }
+    
+    def get_token_for_api_type(self, api_type: DhanAPIType) -> str:
+        """Get the appropriate token for the API type"""
+        if api_type == DhanAPIType.TRADING:
+            if self.settings.DHAN_TRADING_MODE == "paper":
+                return self.settings.DHAN_PAPER_TRADING_TOKEN
+            return self.settings.DHAN_TRADING_API_TOKEN
+        elif api_type == DhanAPIType.DATA:
+            return self.settings.DHAN_DATA_API_TOKEN
+        elif api_type == DhanAPIType.PAPER_TRADING:
+            return self.settings.DHAN_PAPER_TRADING_TOKEN
+        else:
+            raise ValueError(f"Unknown API type: {api_type}")
+    
+    def get_client_id_for_api_type(self, api_type: DhanAPIType) -> str:
+        """Get the appropriate client ID for the API type"""
+        if api_type == DhanAPIType.PAPER_TRADING or self.settings.DHAN_TRADING_MODE == "paper":
+            return self.settings.DHAN_PAPER_TRADING_CLIENT_ID
+        return self.settings.DHAN_CLIENT_ID
+    
+    def get_headers(self, api_type: DhanAPIType) -> Dict[str, str]:
+        """Get API headers for the specified API type"""
+        token = self.get_token_for_api_type(api_type)
+        return {
+            "Content-Type": "application/json",
+            "access-token": token,
+            "Accept": "application/json"
+        }
+    
+    async def make_request(
+        self,
+        api_type: DhanAPIType,
+        endpoint: str,
+        method: str = "GET",
+        data: Optional[Dict] = None,
+        params: Optional[Dict] = None
+    ) -> Dict[str, Any]:
+        """Make API request with appropriate token and error handling"""
+        
+        # Validate endpoint exists for this API type
+        if api_type in self.api_endpoints and endpoint not in self.api_endpoints[api_type].values():
+            # Check if endpoint is a direct path
+            if not endpoint.startswith("/"):
+                # Try to find the endpoint in the mapping
+                mapped_endpoints = self.api_endpoints[api_type]
+                if endpoint in mapped_endpoints:
+                    endpoint = mapped_endpoints[endpoint]
+                else:
+                    logger.warning(f"Endpoint '{endpoint}' not found in {api_type.value} API mapping")
+        
+        url = f"{self.base_url}{endpoint}"
+        headers = self.get_headers(api_type)
+        
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.request(
+                    method=method.upper(),
+                    url=url,
+                    headers=headers,
+                    json=data if method.upper() != "GET" else None,
+                    params=params if method.upper() == "GET" else None
+                )
+                
+                response.raise_for_status()
+                result = response.json()
+                
+                logger.info(f"Dhan {api_type.value} API {method} {endpoint}: {response.status_code}")
+                return result
+                
+        except httpx.HTTPStatusError as e:
+            error_msg = f"Dhan {api_type.value} API HTTP error: {e.response.status_code}"
+            try:
+                error_detail = e.response.json()
+                error_msg += f" - {error_detail.get('message', str(error_detail))}"
+            except:
+                error_msg += f" - {e.response.text}"
+            
+            logger.error(error_msg)
+            raise DhanAPIError(error_msg, e.response.status_code, error_detail if 'error_detail' in locals() else None)
+            
+        except httpx.RequestError as e:
+            error_msg = f"Dhan {api_type.value} API request error: {str(e)}"
+            logger.error(error_msg)
+            raise DhanAPIError(error_msg)
+            
+        except Exception as e:
+            error_msg = f"Dhan {api_type.value} API unexpected error: {str(e)}"
+            logger.error(error_msg)
+            raise DhanAPIError(error_msg)
+    
+    # Trading API Methods
+    async def place_order(self, order_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Place an order using Trading API"""
+        api_type = DhanAPIType.PAPER_TRADING if self.settings.DHAN_TRADING_MODE == "paper" else DhanAPIType.TRADING
+        return await self.make_request(api_type, "/orders", "POST", order_data)
+    
+    async def get_orders(self) -> Dict[str, Any]:
+        """Get orders using Trading API"""
+        api_type = DhanAPIType.PAPER_TRADING if self.settings.DHAN_TRADING_MODE == "paper" else DhanAPIType.TRADING
+        return await self.make_request(api_type, "/orders", "GET")
+    
+    async def get_positions(self) -> Dict[str, Any]:
+        """Get positions using Trading API"""
+        api_type = DhanAPIType.PAPER_TRADING if self.settings.DHAN_TRADING_MODE == "paper" else DhanAPIType.TRADING
+        return await self.make_request(api_type, "/positions", "GET")
+    
+    async def get_holdings(self) -> Dict[str, Any]:
+        """Get holdings using Trading API"""
+        api_type = DhanAPIType.PAPER_TRADING if self.settings.DHAN_TRADING_MODE == "paper" else DhanAPIType.TRADING
+        return await self.make_request(api_type, "/holdings", "GET")
+    
+    async def get_funds(self) -> Dict[str, Any]:
+        """Get funds using Trading API"""
+        api_type = DhanAPIType.PAPER_TRADING if self.settings.DHAN_TRADING_MODE == "paper" else DhanAPIType.TRADING
+        return await self.make_request(api_type, "/funds", "GET")
+    
+    async def cancel_order(self, order_id: str) -> Dict[str, Any]:
+        """Cancel an order using Trading API"""
+        api_type = DhanAPIType.PAPER_TRADING if self.settings.DHAN_TRADING_MODE == "paper" else DhanAPIType.TRADING
+        return await self.make_request(api_type, f"/orders/{order_id}", "DELETE")
+    
+    async def modify_order(self, order_id: str, modifications: Dict[str, Any]) -> Dict[str, Any]:
+        """Modify an order using Trading API"""
+        api_type = DhanAPIType.PAPER_TRADING if self.settings.DHAN_TRADING_MODE == "paper" else DhanAPIType.TRADING
+        return await self.make_request(api_type, f"/orders/{order_id}", "PUT", modifications)
+    
+    # Data API Methods
+    async def get_security_master(self) -> Dict[str, Any]:
+        """Get security master using Data API"""
+        return await self.make_request(DhanAPIType.DATA, "/securitymaster", "GET")
+    
+    async def get_live_feed(self, instruments: list) -> Dict[str, Any]:
+        """Get live market feed using Data API"""
+        data = {"instruments": instruments}
+        return await self.make_request(DhanAPIType.DATA, "/marketfeed/ltp", "POST", data)
+    
+    async def get_quote(self, security_id: str, exchange_segment: str) -> Dict[str, Any]:
+        """Get quote using Data API"""
+        params = {"securityId": security_id, "exchangeSegment": exchange_segment}
+        return await self.make_request(DhanAPIType.DATA, "/marketfeed/quote", "GET", params=params)
+    
+    async def get_ohlc(self, instruments: list) -> Dict[str, Any]:
+        """Get OHLC data using Data API"""
+        data = {"instruments": instruments}
+        return await self.make_request(DhanAPIType.DATA, "/marketfeed/ohlc", "POST", data)
+    
+    async def get_historical_data(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Get historical data using Data API"""
+        return await self.make_request(DhanAPIType.DATA, "/charts/historical", "POST", request_data)
+    
+    async def get_intraday_data(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Get intraday data using Data API"""
+        return await self.make_request(DhanAPIType.DATA, "/charts/intraday", "POST", request_data)
+    
+    async def get_option_chain(self, underlying_security_id: str, exchange_segment: str) -> Dict[str, Any]:
+        """Get option chain using Data API"""
+        params = {"underlyingSecurityId": underlying_security_id, "exchangeSegment": exchange_segment}
+        return await self.make_request(DhanAPIType.DATA, "/optionchain", "GET", params=params)
+    
+    # Utility Methods
+    def get_current_mode(self) -> str:
+        """Get current trading mode"""
+        return self.settings.DHAN_TRADING_MODE
+    
+    def is_paper_trading(self) -> bool:
+        """Check if currently in paper trading mode"""
+        return self.settings.DHAN_TRADING_MODE == "paper"
+    
+    def get_websocket_credentials(self) -> Dict[str, str]:
+        """Get WebSocket credentials for current mode"""
+        if self.is_paper_trading():
+            return {
+                "client_id": self.settings.DHAN_PAPER_TRADING_CLIENT_ID,
+                "access_token": self.settings.DHAN_PAPER_TRADING_TOKEN
+            }
+        else:
+            return {
+                "client_id": self.settings.DHAN_CLIENT_ID,
+                "access_token": self.settings.DHAN_DATA_API_TOKEN
+            }
+
+
+# Global instance
+dhan_api_manager = DhanAPIManager()

services/dhan_websocket.py

@@ -0,0 +1,513 @@
+"""
+Dhan WebSocket Service for Real-time Market Data
+Handles live market feed, order updates, and market depth data
+"""
+
+import json
+import asyncio
+import logging
+from typing import Dict, List, Optional, Callable, Any
+from datetime import datetime
+import websockets
+from websockets.exceptions import ConnectionClosed, WebSocketException
+from dataclasses import dataclass
+from enum import Enum
+
+from config.settings import get_settings
+from .dhan_api_manager import dhan_api_manager
+
+logger = logging.getLogger(__name__)
+settings = get_settings()
+
+
+class DhanWSMessageType(Enum):
+    """Dhan WebSocket message types"""
+    MARKET_FEED_SUBSCRIBE = 15
+    ORDER_UPDATE_LOGIN = 42
+    MARKET_DEPTH_SUBSCRIBE = 23
+    HEARTBEAT = 1
+
+
+@dataclass
+class MarketDataUpdate:
+    """Market data update structure"""
+    security_id: str
+    exchange_segment: str
+    ltp: float
+    change: float
+    change_percent: float
+    volume: int
+    open_price: float
+    high_price: float
+    low_price: float
+    close_price: float
+    timestamp: datetime
+    total_buy_qty: Optional[int] = None
+    total_sell_qty: Optional[int] = None
+
+
+@dataclass
+class OrderUpdate:
+    """Order update structure"""
+    order_id: str
+    client_id: str
+    security_id: str
+    exchange_segment: str
+    order_status: str
+    transaction_type: str
+    quantity: int
+    price: float
+    traded_qty: int
+    traded_price: float
+    avg_traded_price: float
+    order_datetime: datetime
+    update_datetime: datetime
+
+
+@dataclass
+class MarketDepthUpdate:
+    """Market depth update structure"""
+    security_id: str
+    exchange_segment: str
+    bids: List[Dict[str, float]]  # [{"price": float, "quantity": int, "orders": int}]
+    asks: List[Dict[str, float]]  # [{"price": float, "quantity": int, "orders": int}]
+    timestamp: datetime
+
+
+class DhanWebSocketClient:
+    """Dhan WebSocket client for real-time data"""
+    
+    def __init__(self):
+        self.settings = settings
+        self.market_feed_ws: Optional[websockets.WebSocketServerProtocol] = None
+        self.order_update_ws: Optional[websockets.WebSocketServerProtocol] = None
+        self.market_depth_ws: Optional[websockets.WebSocketServerProtocol] = None
+        
+        # Connection status
+        self.is_market_feed_connected = False
+        self.is_order_update_connected = False
+        self.is_market_depth_connected = False
+        
+        # Subscribed instruments
+        self.subscribed_instruments: List[Dict[str, str]] = []
+        self.subscribed_depth_instruments: List[Dict[str, str]] = []
+        
+        # Callbacks
+        self.market_data_callback: Optional[Callable[[MarketDataUpdate], None]] = None
+        self.order_update_callback: Optional[Callable[[OrderUpdate], None]] = None
+        self.market_depth_callback: Optional[Callable[[MarketDepthUpdate], None]] = None
+        
+        # Heartbeat tasks
+        self.market_feed_heartbeat_task: Optional[asyncio.Task] = None
+        self.order_update_heartbeat_task: Optional[asyncio.Task] = None
+        self.market_depth_heartbeat_task: Optional[asyncio.Task] = None
+        
+        # Reconnection parameters
+        self.max_reconnect_attempts = 5
+        self.reconnect_delay = 5  # seconds
+    
+    async def connect_market_feed(self) -> bool:
+        """Connect to Dhan market feed WebSocket"""
+        try:
+            credentials = dhan_api_manager.get_websocket_credentials()
+            url = f"{self.settings.DHAN_WS_MARKET_FEED_URL}?version=2&token={credentials['access_token']}&clientId={credentials['client_id']}&authType=2"
+            
+            self.market_feed_ws = await websockets.connect(url)
+            self.is_market_feed_connected = True
+            
+            logger.info("Connected to Dhan market feed WebSocket")
+            
+            # Start listening for messages
+            asyncio.create_task(self._listen_market_feed())
+            
+            # Start heartbeat
+            self.market_feed_heartbeat_task = asyncio.create_task(self._market_feed_heartbeat())
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to connect to market feed WebSocket: {e}")
+            self.is_market_feed_connected = False
+            return False
+    
+    async def connect_order_updates(self) -> bool:
+        """Connect to Dhan order update WebSocket"""
+        try:
+            self.order_update_ws = await websockets.connect(self.settings.DHAN_WS_ORDER_UPDATE_URL)
+            
+            # Send authorization message
+            credentials = dhan_api_manager.get_websocket_credentials()
+            auth_message = {
+                "LoginReq": {
+                    "MsgCode": DhanWSMessageType.ORDER_UPDATE_LOGIN.value,
+                    "ClientId": credentials['client_id'],
+                    "Token": credentials['access_token']
+                },
+                "UserType": "SELF"
+            }
+            
+            await self.order_update_ws.send(json.dumps(auth_message))
+            self.is_order_update_connected = True
+            
+            logger.info("Connected to Dhan order update WebSocket")
+            
+            # Start listening for messages
+            asyncio.create_task(self._listen_order_updates())
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to connect to order update WebSocket: {e}")
+            self.is_order_update_connected = False
+            return False
+    
+    async def connect_market_depth(self) -> bool:
+        """Connect to Dhan market depth WebSocket"""
+        try:
+            credentials = dhan_api_manager.get_websocket_credentials()
+            url = f"{self.settings.DHAN_WS_MARKET_DEPTH_URL}?token={credentials['access_token']}&clientId={credentials['client_id']}&authType=2"
+            
+            self.market_depth_ws = await websockets.connect(url)
+            self.is_market_depth_connected = True
+            
+            logger.info("Connected to Dhan market depth WebSocket")
+            
+            # Start listening for messages
+            asyncio.create_task(self._listen_market_depth())
+            
+            # Start heartbeat
+            self.market_depth_heartbeat_task = asyncio.create_task(self._market_depth_heartbeat())
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to connect to market depth WebSocket: {e}")
+            self.is_market_depth_connected = False
+            return False
+    
+    async def subscribe_market_data(self, instruments: List[Dict[str, str]]) -> bool:
+        """Subscribe to market data for instruments"""
+        if not self.is_market_feed_connected or not self.market_feed_ws:
+            logger.error("Market feed WebSocket not connected")
+            return False
+        
+        try:
+            # Limit to 5000 instruments per connection
+            if len(instruments) > 5000:
+                logger.warning("Too many instruments, limiting to 5000")
+                instruments = instruments[:5000]
+            
+            subscribe_message = {
+                "RequestCode": DhanWSMessageType.MARKET_FEED_SUBSCRIBE.value,
+                "InstrumentCount": len(instruments),
+                "InstrumentList": [
+                    {
+                        "ExchangeSegment": instrument["exchange_segment"],
+                        "SecurityId": instrument["security_id"]
+                    }
+                    for instrument in instruments
+                ]
+            }
+            
+            await self.market_feed_ws.send(json.dumps(subscribe_message))
+            self.subscribed_instruments.extend(instruments)
+            
+            logger.info(f"Subscribed to {len(instruments)} instruments for market data")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to subscribe to market data: {e}")
+            return False
+    
+    async def subscribe_market_depth(self, instruments: List[Dict[str, str]]) -> bool:
+        """Subscribe to market depth for instruments (max 50 per connection)"""
+        if not self.is_market_depth_connected or not self.market_depth_ws:
+            logger.error("Market depth WebSocket not connected")
+            return False
+        
+        try:
+            # Limit to 50 instruments per connection
+            if len(instruments) > 50:
+                logger.warning("Too many instruments for market depth, limiting to 50")
+                instruments = instruments[:50]
+            
+            subscribe_message = {
+                "RequestCode": DhanWSMessageType.MARKET_DEPTH_SUBSCRIBE.value,
+                "InstrumentCount": len(instruments),
+                "InstrumentList": [
+                    {
+                        "ExchangeSegment": instrument["exchange_segment"],
+                        "SecurityId": instrument["security_id"]
+                    }
+                    for instrument in instruments
+                ]
+            }
+            
+            await self.market_depth_ws.send(json.dumps(subscribe_message))
+            self.subscribed_depth_instruments.extend(instruments)
+            
+            logger.info(f"Subscribed to {len(instruments)} instruments for market depth")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to subscribe to market depth: {e}")
+            return False
+    
+    async def _listen_market_feed(self):
+        """Listen for market feed messages"""
+        try:
+            async for message in self.market_feed_ws:
+                try:
+                    data = json.loads(message)
+                    await self._process_market_data(data)
+                except json.JSONDecodeError:
+                    logger.error(f"Failed to decode market feed message: {message}")
+                except Exception as e:
+                    logger.error(f"Error processing market feed message: {e}")
+                    
+        except ConnectionClosed:
+            logger.warning("Market feed WebSocket connection closed")
+            self.is_market_feed_connected = False
+            await self._reconnect_market_feed()
+        except Exception as e:
+            logger.error(f"Error in market feed listener: {e}")
+            self.is_market_feed_connected = False
+    
+    async def _listen_order_updates(self):
+        """Listen for order update messages"""
+        try:
+            async for message in self.order_update_ws:
+                try:
+                    data = json.loads(message)
+                    await self._process_order_update(data)
+                except json.JSONDecodeError:
+                    logger.error(f"Failed to decode order update message: {message}")
+                except Exception as e:
+                    logger.error(f"Error processing order update message: {e}")
+                    
+        except ConnectionClosed:
+            logger.warning("Order update WebSocket connection closed")
+            self.is_order_update_connected = False
+            await self._reconnect_order_updates()
+        except Exception as e:
+            logger.error(f"Error in order update listener: {e}")
+            self.is_order_update_connected = False
+    
+    async def _listen_market_depth(self):
+        """Listen for market depth messages"""
+        try:
+            async for message in self.market_depth_ws:
+                try:
+                    data = json.loads(message)
+                    await self._process_market_depth(data)
+                except json.JSONDecodeError:
+                    logger.error(f"Failed to decode market depth message: {message}")
+                except Exception as e:
+                    logger.error(f"Error processing market depth message: {e}")
+                    
+        except ConnectionClosed:
+            logger.warning("Market depth WebSocket connection closed")
+            self.is_market_depth_connected = False
+            await self._reconnect_market_depth()
+        except Exception as e:
+            logger.error(f"Error in market depth listener: {e}")
+            self.is_market_depth_connected = False
+    
+    async def _process_market_data(self, data: Dict[str, Any]):
+        """Process market data update"""
+        try:
+            # Parse market data from Dhan format
+            if self.market_data_callback and "SecurityId" in data:
+                market_update = MarketDataUpdate(
+                    security_id=str(data.get("SecurityId", "")),
+                    exchange_segment=data.get("ExchangeSegment", ""),
+                    ltp=float(data.get("LastTradedPrice", 0)),
+                    change=float(data.get("NetChange", 0)),
+                    change_percent=float(data.get("PercentChange", 0)),
+                    volume=int(data.get("TotalTradedQty", 0)),
+                    open_price=float(data.get("OpenPrice", 0)),
+                    high_price=float(data.get("HighPrice", 0)),
+                    low_price=float(data.get("LowPrice", 0)),
+                    close_price=float(data.get("ClosePrice", 0)),
+                    total_buy_qty=data.get("TotalBuyQty"),
+                    total_sell_qty=data.get("TotalSellQty"),
+                    timestamp=datetime.now()
+                )
+                
+                await self.market_data_callback(market_update)
+                
+        except Exception as e:
+            logger.error(f"Error processing market data: {e}")
+    
+    async def _process_order_update(self, data: Dict[str, Any]):
+        """Process order update"""
+        try:
+            if self.order_update_callback and "OrderNo" in data:
+                order_update = OrderUpdate(
+                    order_id=str(data.get("OrderNo", "")),
+                    client_id=str(data.get("ClientId", "")),
+                    security_id=str(data.get("SecurityId", "")),
+                    exchange_segment=data.get("Segment", ""),
+                    order_status=data.get("Status", ""),
+                    transaction_type=data.get("TxnType", ""),
+                    quantity=int(data.get("Quantity", 0)),
+                    price=float(data.get("Price", 0)),
+                    traded_qty=int(data.get("TradedQty", 0)),
+                    traded_price=float(data.get("TradedPrice", 0)),
+                    avg_traded_price=float(data.get("AvgTradedPrice", 0)),
+                    order_datetime=datetime.now(),
+                    update_datetime=datetime.now()
+                )
+                
+                await self.order_update_callback(order_update)
+                
+        except Exception as e:
+            logger.error(f"Error processing order update: {e}")
+    
+    async def _process_market_depth(self, data: Dict[str, Any]):
+        """Process market depth update"""
+        try:
+            if self.market_depth_callback and "SecurityId" in data:
+                bids = []
+                asks = []
+                
+                # Parse bid and ask data
+                for i in range(1, 21):  # 20 levels
+                    bid_price = data.get(f"BidPrice{i}")
+                    bid_qty = data.get(f"BidQty{i}")
+                    bid_orders = data.get(f"BidOrders{i}")
+                    
+                    if bid_price and bid_qty:
+                        bids.append({
+                            "price": float(bid_price),
+                            "quantity": int(bid_qty),
+                            "orders": int(bid_orders or 0)
+                        })
+                    
+                    ask_price = data.get(f"AskPrice{i}")
+                    ask_qty = data.get(f"AskQty{i}")
+                    ask_orders = data.get(f"AskOrders{i}")
+                    
+                    if ask_price and ask_qty:
+                        asks.append({
+                            "price": float(ask_price),
+                            "quantity": int(ask_qty),
+                            "orders": int(ask_orders or 0)
+                        })
+                
+                depth_update = MarketDepthUpdate(
+                    security_id=str(data.get("SecurityId", "")),
+                    exchange_segment=data.get("ExchangeSegment", ""),
+                    bids=bids,
+                    asks=asks,
+                    timestamp=datetime.now()
+                )
+                
+                await self.market_depth_callback(depth_update)
+                
+        except Exception as e:
+            logger.error(f"Error processing market depth: {e}")
+    
+    async def _market_feed_heartbeat(self):
+        """Send heartbeat to keep market feed connection alive"""
+        while self.is_market_feed_connected:
+            try:
+                await asyncio.sleep(30)  # Send heartbeat every 30 seconds
+                if self.market_feed_ws and self.is_market_feed_connected:
+                    await self.market_feed_ws.ping()
+            except Exception as e:
+                logger.error(f"Market feed heartbeat error: {e}")
+                break
+    
+    async def _market_depth_heartbeat(self):
+        """Send heartbeat to keep market depth connection alive"""
+        while self.is_market_depth_connected:
+            try:
+                await asyncio.sleep(30)  # Send heartbeat every 30 seconds
+                if self.market_depth_ws and self.is_market_depth_connected:
+                    await self.market_depth_ws.ping()
+            except Exception as e:
+                logger.error(f"Market depth heartbeat error: {e}")
+                break
+    
+    async def _reconnect_market_feed(self):
+        """Reconnect to market feed WebSocket"""
+        for attempt in range(self.max_reconnect_attempts):
+            logger.info(f"Attempting to reconnect market feed (attempt {attempt + 1})")
+            await asyncio.sleep(self.reconnect_delay)
+            
+            if await self.connect_market_feed():
+                # Re-subscribe to instruments
+                if self.subscribed_instruments:
+                    await self.subscribe_market_data(self.subscribed_instruments)
+                return
+        
+        logger.error("Failed to reconnect market feed after maximum attempts")
+    
+    async def _reconnect_order_updates(self):
+        """Reconnect to order update WebSocket"""
+        for attempt in range(self.max_reconnect_attempts):
+            logger.info(f"Attempting to reconnect order updates (attempt {attempt + 1})")
+            await asyncio.sleep(self.reconnect_delay)
+            
+            if await self.connect_order_updates():
+                return
+        
+        logger.error("Failed to reconnect order updates after maximum attempts")
+    
+    async def _reconnect_market_depth(self):
+        """Reconnect to market depth WebSocket"""
+        for attempt in range(self.max_reconnect_attempts):
+            logger.info(f"Attempting to reconnect market depth (attempt {attempt + 1})")
+            await asyncio.sleep(self.reconnect_delay)
+            
+            if await self.connect_market_depth():
+                # Re-subscribe to instruments
+                if self.subscribed_depth_instruments:
+                    await self.subscribe_market_depth(self.subscribed_depth_instruments)
+                return
+        
+        logger.error("Failed to reconnect market depth after maximum attempts")
+    
+    def set_market_data_callback(self, callback: Callable[[MarketDataUpdate], None]):
+        """Set callback for market data updates"""
+        self.market_data_callback = callback
+    
+    def set_order_update_callback(self, callback: Callable[[OrderUpdate], None]):
+        """Set callback for order updates"""
+        self.order_update_callback = callback
+    
+    def set_market_depth_callback(self, callback: Callable[[MarketDepthUpdate], None]):
+        """Set callback for market depth updates"""
+        self.market_depth_callback = callback
+    
+    async def disconnect_all(self):
+        """Disconnect all WebSocket connections"""
+        try:
+            # Cancel heartbeat tasks
+            if self.market_feed_heartbeat_task:
+                self.market_feed_heartbeat_task.cancel()
+            if self.market_depth_heartbeat_task:
+                self.market_depth_heartbeat_task.cancel()
+            
+            # Close connections
+            if self.market_feed_ws:
+                await self.market_feed_ws.close()
+            if self.order_update_ws:
+                await self.order_update_ws.close()
+            if self.market_depth_ws:
+                await self.market_depth_ws.close()
+            
+            # Reset connection status
+            self.is_market_feed_connected = False
+            self.is_order_update_connected = False
+            self.is_market_depth_connected = False
+            
+            logger.info("All WebSocket connections closed")
+            
+        except Exception as e:
+            logger.error(f"Error disconnecting WebSockets: {e}")
+
+
+# Global WebSocket client instance
+dhan_ws_client = DhanWebSocketClient()

services/market_data.py

@@ -0,0 +1,396 @@
+"""
+Market Data Service
+Handles market data fetching, caching, and processing
+"""
+
+import logging
+from typing import Dict, List, Any, Optional
+from datetime import datetime, timedelta
+import asyncio
+import random
+
+from services.dhan_api_manager import dhan_api_manager, DhanAPIError
+
+logger = logging.getLogger(__name__)
+
+class MarketDataService:
+    """Service for market data operations"""
+    
+    def __init__(self):
+        self.dhan_api = dhan_api_manager
+        self.cache = {}
+        self.cache_ttl = 60  # 1 minute cache
+    
+    async def get_market_data_batch(self, securities: List[Dict[str, str]]) -> List[Dict[str, Any]]:
+        """Get market data for multiple securities"""
+        try:
+            market_data = []
+            
+            for security in securities:
+                data = await self.get_single_security_data(
+                    security.get("security_id", ""),
+                    security.get("exchange_segment", "NSE_EQ")
+                )
+                if data:
+                    market_data.append(data)
+            
+            return market_data
+            
+        except Exception as e:
+            logger.error(f"Error getting batch market data: {e}")
+            raise
+    
+    async def get_single_security_data(self, security_id: str, exchange_segment: str) -> Optional[Dict[str, Any]]:
+        """Get market data for a single security"""
+        try:
+            cache_key = f"{security_id}_{exchange_segment}"
+            
+            # Check cache first
+            if cache_key in self.cache:
+                cached_data, timestamp = self.cache[cache_key]
+                if datetime.utcnow() - timestamp < timedelta(seconds=self.cache_ttl):
+                    return cached_data
+            
+            # Fetch from Dhan API
+            try:
+                result = await self.dhan_api.get_quote(security_id, exchange_segment)
+                
+                if result and "data" in result:
+                    data = result["data"]
+                    
+                    # Standardize the data format
+                    standardized_data = {
+                        "security_id": security_id,
+                        "exchange_segment": exchange_segment,
+                        "symbol": data.get("tradingSymbol", ""),
+                        "ltp": float(data.get("LTP", 0)),
+                        "change": float(data.get("change", 0)),
+                        "change_percent": float(data.get("pChange", 0)),
+                        "volume": int(data.get("volume", 0)),
+                        "open": float(data.get("open", 0)),
+                        "high": float(data.get("high", 0)),
+                        "low": float(data.get("low", 0)),
+                        "close": float(data.get("close", 0)),
+                        "timestamp": datetime.utcnow().isoformat()
+                    }
+                    
+                    # Cache the data
+                    self.cache[cache_key] = (standardized_data, datetime.utcnow())
+                    
+                    return standardized_data
+                
+            except DhanAPIError as e:
+                logger.warning(f"Dhan API error for {security_id}: {e}")
+                # Fall back to mock data
+                return self._generate_mock_data(security_id, exchange_segment)
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"Error getting single security data for {security_id}: {e}")
+            return self._generate_mock_data(security_id, exchange_segment)
+    
+    def _generate_mock_data(self, security_id: str, exchange_segment: str) -> Dict[str, Any]:
+        """Generate mock market data for testing"""
+        
+        # Mock data based on common symbols
+        mock_prices = {
+            "2885": 2650.0,  # RELIANCE
+            "11723": 3890.0,  # TCS
+            "1333": 1580.0,   # HDFC
+            "1594": 1685.0,   # INFY
+        }
+        
+        base_price = mock_prices.get(security_id, random.uniform(100, 5000))
+        change_percent = random.uniform(-3, 3)
+        change = base_price * change_percent / 100
+        
+        return {
+            "security_id": security_id,
+            "exchange_segment": exchange_segment,
+            "symbol": f"SYMBOL_{security_id}",
+            "ltp": round(base_price + change, 2),
+            "change": round(change, 2),
+            "change_percent": round(change_percent, 2),
+            "volume": random.randint(100000, 5000000),
+            "open": round(base_price * random.uniform(0.98, 1.02), 2),
+            "high": round(base_price * random.uniform(1.01, 1.05), 2),
+            "low": round(base_price * random.uniform(0.95, 0.99), 2),
+            "close": round(base_price, 2),
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    
+    async def get_historical_data(
+        self, 
+        security_id: str, 
+        exchange_segment: str, 
+        from_date: str, 
+        to_date: str,
+        interval: str = "day"
+    ) -> List[Dict[str, Any]]:
+        """Get historical data for a security"""
+        try:
+            # Try to get from Dhan API
+            request_data = {
+                "securityId": security_id,
+                "exchangeSegment": exchange_segment,
+                "instrument": "EQUITY",
+                "interval": interval,
+                "fromDate": from_date,
+                "toDate": to_date
+            }
+            
+            try:
+                result = await self.dhan_api.get_historical_data(request_data)
+                if result and "data" in result:
+                    return result["data"]
+            except DhanAPIError as e:
+                logger.warning(f"Dhan API error getting historical data: {e}")
+            
+            # Fall back to mock data
+            return self._generate_mock_historical_data(from_date, to_date, interval)
+            
+        except Exception as e:
+            logger.error(f"Error getting historical data: {e}")
+            return []
+    
+    def _generate_mock_historical_data(self, from_date: str, to_date: str, interval: str) -> List[Dict[str, Any]]:
+        """Generate mock historical data"""
+        try:
+            start_date = datetime.strptime(from_date, "%Y-%m-%d")
+            end_date = datetime.strptime(to_date, "%Y-%m-%d")
+            
+            data_points = []
+            current_date = start_date
+            base_price = random.uniform(1000, 3000)
+            
+            while current_date <= end_date:
+                # Simulate price movement
+                change_percent = random.uniform(-2, 2)
+                open_price = base_price
+                close_price = base_price * (1 + change_percent / 100)
+                high_price = max(open_price, close_price) * random.uniform(1.001, 1.02)
+                low_price = min(open_price, close_price) * random.uniform(0.98, 0.999)
+                
+                data_points.append({
+                    "timestamp": current_date.strftime("%Y-%m-%d"),
+                    "open": round(open_price, 2),
+                    "high": round(high_price, 2),
+                    "low": round(low_price, 2),
+                    "close": round(close_price, 2),
+                    "volume": random.randint(100000, 2000000)
+                })
+                
+                base_price = close_price
+                current_date += timedelta(days=1)
+            
+            return data_points
+            
+        except Exception as e:
+            logger.error(f"Error generating mock historical data: {e}")
+            return []
+    
+    async def get_live_quotes(self, symbols: List[str]) -> Dict[str, Dict[str, Any]]:
+        """Get live quotes for multiple symbols"""
+        try:
+            quotes = {}
+            
+            for symbol in symbols:
+                # This is a simplified implementation
+                # In reality, you'd need to map symbols to security_ids
+                quote_data = await self.get_single_security_data(symbol, "NSE_EQ")
+                if quote_data:
+                    quotes[symbol] = quote_data
+            
+            return quotes
+            
+        except Exception as e:
+            logger.error(f"Error getting live quotes: {e}")
+            return {}
+    
+    async def get_market_indices(self) -> Dict[str, Dict[str, Any]]:
+        """Get major market indices data"""
+        try:
+            indices = {}
+            
+            # Major Indian indices
+            index_mapping = {
+                "NIFTY": {"security_id": "26000", "exchange_segment": "NSE_INDEX"},
+                "SENSEX": {"security_id": "1", "exchange_segment": "BSE_INDEX"},
+                "BANKNIFTY": {"security_id": "26009", "exchange_segment": "NSE_INDEX"}
+            }
+            
+            for index_name, mapping in index_mapping.items():
+                try:
+                    data = await self.get_single_security_data(
+                        mapping["security_id"], 
+                        mapping["exchange_segment"]
+                    )
+                    if data:
+                        indices[index_name] = data
+                except Exception as e:
+                    logger.warning(f"Error getting data for {index_name}: {e}")
+                    # Add mock data for the index
+                    indices[index_name] = self._generate_mock_index_data(index_name)
+            
+            return indices
+            
+        except Exception as e:
+            logger.error(f"Error getting market indices: {e}")
+            return {}
+    
+    def _generate_mock_index_data(self, index_name: str) -> Dict[str, Any]:
+        """Generate mock index data"""
+        base_values = {
+            "NIFTY": 22000,
+            "SENSEX": 72000,
+            "BANKNIFTY": 47000
+        }
+        
+        base_value = base_values.get(index_name, 10000)
+        change_percent = random.uniform(-1, 1.5)
+        change = base_value * change_percent / 100
+        
+        return {
+            "symbol": index_name,
+            "ltp": round(base_value + change, 2),
+            "change": round(change, 2),
+            "change_percent": round(change_percent, 2),
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    
+    async def get_sector_data(self) -> List[Dict[str, Any]]:
+        """Get sector-wise performance data"""
+        try:
+            sectors = [
+                {
+                    "sector": "Information Technology",
+                    "change_percent": random.uniform(-2, 3),
+                    "market_cap": random.uniform(8000000000000, 15000000000000),
+                    "stocks_count": 25
+                },
+                {
+                    "sector": "Banking",
+                    "change_percent": random.uniform(-1.5, 2),
+                    "market_cap": random.uniform(6000000000000, 12000000000000),
+                    "stocks_count": 30
+                },
+                {
+                    "sector": "Oil & Gas",
+                    "change_percent": random.uniform(-1, 2.5),
+                    "market_cap": random.uniform(4000000000000, 8000000000000),
+                    "stocks_count": 15
+                },
+                {
+                    "sector": "Pharmaceuticals",
+                    "change_percent": random.uniform(-0.5, 1.8),
+                    "market_cap": random.uniform(3000000000000, 6000000000000),
+                    "stocks_count": 20
+                },
+                {
+                    "sector": "Automotive",
+                    "change_percent": random.uniform(-2, 1.5),
+                    "market_cap": random.uniform(2000000000000, 5000000000000),
+                    "stocks_count": 18
+                }
+            ]
+            
+            return sectors
+            
+        except Exception as e:
+            logger.error(f"Error getting sector data: {e}")
+            return []
+    
+    async def get_top_movers(self, mover_type: str = "gainers", limit: int = 20) -> List[Dict[str, Any]]:
+        """Get top gainers or losers"""
+        try:
+            # This would typically fetch real data from the API
+            # For now, generating mock data
+            
+            movers = []
+            
+            for i in range(limit):
+                if mover_type == "gainers":
+                    change_percent = random.uniform(3, 15)
+                else:  # losers
+                    change_percent = random.uniform(-15, -3)
+                
+                base_price = random.uniform(100, 5000)
+                change = base_price * change_percent / 100
+                
+                movers.append({
+                    "symbol": f"STOCK{i+1}",
+                    "security_id": f"{1000+i}",
+                    "ltp": round(base_price + change, 2),
+                    "change": round(change, 2),
+                    "change_percent": round(change_percent, 2),
+                    "volume": random.randint(500000, 10000000)
+                })
+            
+            # Sort by change percentage
+            movers.sort(key=lambda x: x["change_percent"], reverse=(mover_type == "gainers"))
+            
+            return movers
+            
+        except Exception as e:
+            logger.error(f"Error getting top {mover_type}: {e}")
+            return []
+    
+    async def get_option_chain(self, underlying_symbol: str, expiry_date: Optional[str] = None) -> Dict[str, Any]:
+        """Get option chain data"""
+        try:
+            # This is a complex endpoint that would need significant implementation
+            # For now, returning mock structure
+            
+            return {
+                "underlying": underlying_symbol,
+                "expiry_date": expiry_date or (datetime.utcnow() + timedelta(days=30)).strftime("%Y-%m-%d"),
+                "underlying_price": random.uniform(2000, 3000),
+                "options": {
+                    "calls": [
+                        {
+                            "strike": strike,
+                            "ltp": random.uniform(10, 200),
+                            "change": random.uniform(-20, 20),
+                            "volume": random.randint(1000, 100000),
+                            "oi": random.randint(5000, 500000)
+                        }
+                        for strike in range(2000, 3200, 50)
+                    ],
+                    "puts": [
+                        {
+                            "strike": strike,
+                            "ltp": random.uniform(10, 200),
+                            "change": random.uniform(-20, 20),
+                            "volume": random.randint(1000, 100000),
+                            "oi": random.randint(5000, 500000)
+                        }
+                        for strike in range(2000, 3200, 50)
+                    ]
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"Error getting option chain: {e}")
+            return {}
+    
+    def clear_cache(self):
+        """Clear the market data cache"""
+        self.cache.clear()
+        logger.info("Market data cache cleared")
+    
+    def get_cache_stats(self) -> Dict[str, Any]:
+        """Get cache statistics"""
+        now = datetime.utcnow()
+        active_entries = 0
+        
+        for cache_key, (data, timestamp) in self.cache.items():
+            if now - timestamp < timedelta(seconds=self.cache_ttl):
+                active_entries += 1
+        
+        return {
+            "total_entries": len(self.cache),
+            "active_entries": active_entries,
+            "cache_ttl": self.cache_ttl,
+            "last_cleared": now.isoformat()
+        }

services/portfolio_service.py

@@ -0,0 +1,374 @@
+"""
+Portfolio Service
+Handles portfolio calculations, analytics, and optimization
+"""
+
+import logging
+from typing import Dict, List, Any, Optional
+from datetime import datetime, timedelta
+import asyncio
+import numpy as np
+import pandas as pd
+
+from models.portfolio import (
+    PortfolioSummary, PortfolioHolding, PerformanceMetrics, 
+    AllocationRequest, RiskMetrics
+)
+from services.dhan_api_manager import dhan_api_manager
+
+logger = logging.getLogger(__name__)
+
+class PortfolioService:
+    """Service for portfolio management and analytics"""
+    
+    def __init__(self):
+        self.dhan_api = dhan_api_manager
+    
+    async def get_portfolio_summary(self, user_id: str) -> PortfolioSummary:
+        """Get comprehensive portfolio summary"""
+        try:
+            # Get holdings and positions
+            holdings_result = await self.dhan_api.get_holdings()
+            holdings = holdings_result.get("data", [])
+            
+            # Calculate summary metrics
+            total_value = sum(holding.get("currentValue", 0) for holding in holdings)
+            total_invested = sum(holding.get("avgPrice", 0) * holding.get("totalQty", 0) for holding in holdings)
+            total_pnl = total_value - total_invested
+            pnl_percentage = (total_pnl / total_invested * 100) if total_invested > 0 else 0
+            
+            # Mock day's change calculation
+            day_change = total_value * 0.015  # Mock 1.5% daily change
+            day_change_percentage = 1.5
+            
+            return PortfolioSummary(
+                total_value=total_value,
+                total_invested=total_invested,
+                total_pnl=total_pnl,
+                pnl_percentage=pnl_percentage,
+                day_change=day_change,
+                day_change_percentage=day_change_percentage,
+                holdings_count=len(holdings),
+                last_updated=datetime.utcnow()
+            )
+            
+        except Exception as e:
+            logger.error(f"Error getting portfolio summary: {e}")
+            raise
+    
+    async def get_holdings(self, user_id: str) -> List[Dict[str, Any]]:
+        """Get user's holdings"""
+        try:
+            holdings_result = await self.dhan_api.get_holdings()
+            return holdings_result.get("data", [])
+        except Exception as e:
+            logger.error(f"Error getting holdings: {e}")
+            raise
+    
+    async def calculate_performance_metrics(
+        self, 
+        user_id: str, 
+        start_date: datetime, 
+        end_date: datetime
+    ) -> PerformanceMetrics:
+        """Calculate portfolio performance metrics"""
+        try:
+            # Mock implementation - in real system would analyze historical data
+            days = (end_date - start_date).days
+            
+            return PerformanceMetrics(
+                total_return=8.5,
+                annualized_return=12.8,
+                best_day=3.2,
+                worst_day=-2.8,
+                positive_days=int(days * 0.6),
+                negative_days=int(days * 0.4),
+                win_rate=60.0,
+                calmar_ratio=0.85,
+                tracking_error=2.1
+            )
+            
+        except Exception as e:
+            logger.error(f"Error calculating performance metrics: {e}")
+            raise
+    
+    async def get_asset_allocation(self, user_id: str) -> Dict[str, Any]:
+        """Get current asset allocation breakdown"""
+        try:
+            holdings = await self.get_holdings(user_id)
+            
+            # Mock allocation calculation
+            # In real implementation, would categorize holdings by sector, market cap, etc.
+            
+            return {
+                "sectors": {
+                    "Information Technology": 35.5,
+                    "Banking": 25.2,
+                    "Pharmaceuticals": 15.8,
+                    "Automotive": 12.3,
+                    "Oil & Gas": 11.2
+                },
+                "market_caps": {
+                    "Large Cap": 65.0,
+                    "Mid Cap": 25.0,
+                    "Small Cap": 10.0
+                },
+                "geography": {
+                    "Domestic": 85.0,
+                    "International": 15.0
+                },
+                "concentration": {
+                    "top_5_holdings": 45.2,
+                    "top_10_holdings": 67.8
+                },
+                "diversification_score": 75.5
+            }
+            
+        except Exception as e:
+            logger.error(f"Error calculating asset allocation: {e}")
+            raise
+    
+    async def calculate_rebalancing(
+        self, 
+        current_portfolio: List[Dict], 
+        target_allocation: AllocationRequest
+    ) -> Dict[str, Any]:
+        """Calculate portfolio rebalancing suggestions"""
+        try:
+            # Mock rebalancing calculation
+            total_value = sum(holding.get("currentValue", 0) for holding in current_portfolio)
+            
+            return {
+                "current": {
+                    "equity": 80.0,
+                    "debt": 15.0,
+                    "cash": 5.0
+                },
+                "target": {
+                    "equity": 70.0,
+                    "debt": 25.0,
+                    "cash": 5.0
+                },
+                "trades": [
+                    {
+                        "action": "sell",
+                        "security": "RELIANCE",
+                        "quantity": 50,
+                        "amount": 125000
+                    },
+                    {
+                        "action": "buy",
+                        "security": "DEBT_FUND",
+                        "amount": 125000
+                    }
+                ],
+                "cost": 500.0,  # Transaction costs
+                "tax_impact": 2500.0  # Estimated tax
+            }
+            
+        except Exception as e:
+            logger.error(f"Error calculating rebalancing: {e}")
+            raise
+    
+    async def calculate_correlation_matrix(self, holdings: List[Dict]) -> List[List[float]]:
+        """Calculate correlation matrix for portfolio holdings"""
+        try:
+            # Mock correlation matrix
+            n_holdings = min(len(holdings), 10)  # Limit to 10 holdings
+            
+            # Generate mock correlation matrix
+            np.random.seed(42)  # For consistent results
+            correlation_matrix = np.random.uniform(0.1, 0.8, (n_holdings, n_holdings))
+            
+            # Make matrix symmetric and set diagonal to 1
+            for i in range(n_holdings):
+                for j in range(i, n_holdings):
+                    if i == j:
+                        correlation_matrix[i][j] = 1.0
+                    else:
+                        correlation_matrix[j][i] = correlation_matrix[i][j]
+            
+            return correlation_matrix.tolist()
+            
+        except Exception as e:
+            logger.error(f"Error calculating correlation matrix: {e}")
+            raise
+    
+    async def get_portfolio_for_var_calculation(self, user_id: str) -> Dict[str, Any]:
+        """Get portfolio data formatted for VaR calculation"""
+        try:
+            holdings = await self.get_holdings(user_id)
+            
+            return {
+                "holdings": holdings,
+                "total_value": sum(h.get("currentValue", 0) for h in holdings),
+                "weights": [h.get("currentValue", 0) for h in holdings],
+                "symbols": [h.get("tradingSymbol", "") for h in holdings]
+            }
+            
+        except Exception as e:
+            logger.error(f"Error getting portfolio for VaR: {e}")
+            raise
+    
+    async def optimize_portfolio(
+        self, 
+        current_portfolio: List[Dict], 
+        objective: str, 
+        constraints: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Run portfolio optimization"""
+        try:
+            # Mock optimization results
+            return {
+                "current": {
+                    "expected_return": 12.5,
+                    "volatility": 18.2,
+                    "sharpe_ratio": 0.65
+                },
+                "optimal": {
+                    "expected_return": 14.2,
+                    "volatility": 16.8,
+                    "sharpe_ratio": 0.82
+                },
+                "expected_return": 14.2,
+                "expected_volatility": 16.8,
+                "sharpe_ratio": 0.82,
+                "changes": [
+                    {
+                        "security": "RELIANCE",
+                        "current_weight": 15.0,
+                        "optimal_weight": 12.0,
+                        "change": -3.0
+                    },
+                    {
+                        "security": "TCS",
+                        "current_weight": 10.0,
+                        "optimal_weight": 13.0,
+                        "change": 3.0
+                    }
+                ]
+            }
+            
+        except Exception as e:
+            logger.error(f"Error optimizing portfolio: {e}")
+            raise
+    
+    async def get_holdings_with_cost_basis(self, user_id: str) -> List[Dict[str, Any]]:
+        """Get holdings with detailed cost basis information"""
+        try:
+            holdings = await self.get_holdings(user_id)
+            
+            # Add mock cost basis data
+            for holding in holdings:
+                holding["purchase_date"] = "2023-01-15"  # Mock data
+                holding["cost_basis"] = holding.get("avgPrice", 0) * holding.get("totalQty", 0)
+                holding["days_held"] = 180  # Mock data
+                holding["is_long_term"] = holding["days_held"] > 365
+            
+            return holdings
+            
+        except Exception as e:
+            logger.error(f"Error getting holdings with cost basis: {e}")
+            raise
+    
+    async def calculate_tax_optimization(
+        self, 
+        holdings: List[Dict], 
+        tax_year: int
+    ) -> Dict[str, Any]:
+        """Calculate tax optimization strategies"""
+        try:
+            # Mock tax optimization calculation
+            total_gains = sum(h.get("pnl", 0) for h in holdings if h.get("pnl", 0) > 0)
+            total_losses = sum(h.get("pnl", 0) for h in holdings if h.get("pnl", 0) < 0)
+            
+            return {
+                "current_liability": max(0, total_gains * 0.15),  # Mock 15% tax
+                "loss_harvesting": [
+                    {
+                        "security": h.get("tradingSymbol"),
+                        "unrealized_loss": h.get("pnl", 0),
+                        "tax_benefit": abs(h.get("pnl", 0)) * 0.15
+                    }
+                    for h in holdings if h.get("pnl", 0) < -5000  # Loss > 5000
+                ][:5],  # Top 5 opportunities
+                "wash_sale_warnings": [],
+                "actions": [
+                    "Consider booking losses in HDFC before year-end",
+                    "Hold TCS for long-term capital gains treatment"
+                ],
+                "potential_savings": abs(total_losses) * 0.15
+            }
+            
+        except Exception as e:
+            logger.error(f"Error calculating tax optimization: {e}")
+            raise
+    
+    async def compare_with_benchmark(
+        self, 
+        user_id: str, 
+        benchmark: str, 
+        start_date: datetime, 
+        end_date: datetime
+    ) -> Dict[str, Any]:
+        """Compare portfolio performance with benchmark"""
+        try:
+            # Mock benchmark comparison
+            return {
+                "portfolio_return": 12.5,
+                "benchmark_return": 8.7,
+                "alpha": 3.8,
+                "beta": 1.15,
+                "tracking_error": 4.2,
+                "information_ratio": 0.90,
+                "up_capture": 110.5,
+                "down_capture": 85.2
+            }
+            
+        except Exception as e:
+            logger.error(f"Error comparing with benchmark: {e}")
+            raise
+    
+    async def simulate_portfolio_changes(
+        self, 
+        current_portfolio: List[Dict], 
+        proposed_changes: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """Simulate the impact of portfolio changes"""
+        try:
+            # Mock simulation results
+            current_value = sum(h.get("currentValue", 0) for h in current_portfolio)
+            
+            return {
+                "current": {
+                    "value": current_value,
+                    "risk": 18.5,
+                    "expected_return": 12.0,
+                    "sharpe_ratio": 0.65
+                },
+                "projected": {
+                    "value": current_value * 1.05,  # 5% increase assumed
+                    "risk": 16.8,
+                    "expected_return": 13.2,
+                    "sharpe_ratio": 0.78
+                },
+                "impact": {
+                    "risk_change": -1.7,
+                    "return_change": 1.2,
+                    "sharpe_improvement": 0.13
+                },
+                "risk_change": {
+                    "before": 18.5,
+                    "after": 16.8,
+                    "improvement": True
+                },
+                "recommendations": [
+                    "The proposed changes will improve risk-adjusted returns",
+                    "Consider gradual implementation over 2-3 weeks",
+                    "Monitor market conditions before executing"
+                ]
+            }
+            
+        except Exception as e:
+            logger.error(f"Error simulating portfolio changes: {e}")
+            raise

services/risk_engine.py

@@ -0,0 +1,390 @@
+"""
+Risk Engine Service
+Handles portfolio risk assessment, VaR calculations, and stress testing
+"""
+
+import logging
+from typing import Dict, List, Any, Optional
+from datetime import datetime, timedelta
+import numpy as np
+import pandas as pd
+
+from models.portfolio import RiskAssessment, RiskLevel
+
+logger = logging.getLogger(__name__)
+
+class RiskEngine:
+    """Service for portfolio risk analysis and management"""
+    
+    def __init__(self):
+        self.confidence_levels = [0.95, 0.99]
+        self.time_horizons = [1, 5, 21]  # 1 day, 1 week, 1 month
+    
+    async def assess_portfolio_risk(self, holdings: List[Dict[str, Any]]) -> RiskAssessment:
+        """Perform comprehensive portfolio risk assessment"""
+        try:
+            # Calculate various risk metrics
+            concentration_risk = self._calculate_concentration_risk(holdings)
+            sector_concentration = self._calculate_sector_concentration(holdings)
+            liquidity_risk = self._calculate_liquidity_risk(holdings)
+            currency_risk = self._calculate_currency_risk(holdings)
+            
+            # Calculate overall risk score
+            overall_risk_score = self._calculate_overall_risk_score(
+                concentration_risk, liquidity_risk, currency_risk
+            )
+            
+            # Determine risk level
+            risk_level = self._determine_risk_level(overall_risk_score)
+            
+            # Generate recommendations
+            recommendations = self._generate_risk_recommendations(
+                overall_risk_score, concentration_risk, sector_concentration
+            )
+            
+            return RiskAssessment(
+                overall_risk_score=overall_risk_score,
+                risk_level=risk_level,
+                concentration_risk=concentration_risk,
+                sector_concentration=sector_concentration,
+                liquidity_risk=liquidity_risk,
+                currency_risk=currency_risk,
+                recommendations=recommendations
+            )
+            
+        except Exception as e:
+            logger.error(f"Error assessing portfolio risk: {e}")
+            raise
+    
+    async def calculate_value_at_risk(
+        self, 
+        portfolio_data: Dict[str, Any], 
+        confidence_level: float = 0.95,
+        time_horizon: int = 1
+    ) -> Dict[str, Any]:
+        """Calculate Value at Risk using multiple methods"""
+        try:
+            portfolio_value = portfolio_data.get("total_value", 0)
+            holdings = portfolio_data.get("holdings", [])
+            
+            # Mock VaR calculations (in real system would use historical data)
+            # Historical VaR
+            historical_var = portfolio_value * 0.02 * np.sqrt(time_horizon)
+            
+            # Parametric VaR
+            portfolio_volatility = 0.18  # Mock 18% annual volatility
+            daily_volatility = portfolio_volatility / np.sqrt(252)
+            z_score = 1.645 if confidence_level == 0.95 else 2.326  # For 95% and 99%
+            parametric_var = portfolio_value * z_score * daily_volatility * np.sqrt(time_horizon)
+            
+            # Monte Carlo VaR
+            monte_carlo_var = portfolio_value * 0.025 * np.sqrt(time_horizon)
+            
+            # Expected Shortfall (Conditional VaR)
+            expected_shortfall = parametric_var * 1.3  # Typically 30% higher than VaR
+            
+            return {
+                "historical": historical_var,
+                "parametric": parametric_var,
+                "monte_carlo": monte_carlo_var,
+                "expected_shortfall": expected_shortfall,
+                "portfolio_value": portfolio_value,
+                "confidence_level": confidence_level,
+                "time_horizon": time_horizon
+            }
+            
+        except Exception as e:
+            logger.error(f"Error calculating VaR: {e}")
+            raise
+    
+    async def run_stress_testing(
+        self, 
+        portfolio_data: List[Dict[str, Any]], 
+        scenario: str
+    ) -> Dict[str, Any]:
+        """Run stress testing scenarios on portfolio"""
+        try:
+            total_value = sum(holding.get("currentValue", 0) for holding in portfolio_data)
+            
+            # Define stress scenarios
+            scenarios = {
+                "market_crash": {
+                    "description": "20% market decline scenario",
+                    "market_impact": -0.20,
+                    "sector_impacts": {
+                        "Banking": -0.25,
+                        "IT": -0.15,
+                        "Auto": -0.30,
+                        "Pharma": -0.10
+                    }
+                },
+                "interest_rate_shock": {
+                    "description": "2% interest rate increase",
+                    "market_impact": -0.12,
+                    "sector_impacts": {
+                        "Banking": 0.05,  # Banks benefit from higher rates
+                        "Real Estate": -0.20,
+                        "IT": -0.10,
+                        "FMCG": -0.08
+                    }
+                },
+                "inflation_surge": {
+                    "description": "High inflation scenario",
+                    "market_impact": -0.15,
+                    "sector_impacts": {
+                        "FMCG": -0.20,
+                        "Auto": -0.18,
+                        "IT": -0.05,
+                        "Commodities": 0.10
+                    }
+                }
+            }
+            
+            scenario_data = scenarios.get(scenario, scenarios["market_crash"])
+            
+            # Calculate portfolio impact
+            portfolio_impact = total_value * scenario_data["market_impact"]
+            impact_percentage = scenario_data["market_impact"] * 100
+            
+            # Calculate most affected holdings (mock)
+            worst_affected = [
+                {
+                    "symbol": "HDFC",
+                    "current_value": 150000,
+                    "stressed_value": 120000,
+                    "impact": -20.0
+                },
+                {
+                    "symbol": "MARUTI",
+                    "current_value": 200000,
+                    "stressed_value": 140000,
+                    "impact": -30.0
+                }
+            ]
+            
+            recommendations = self._generate_stress_test_recommendations(scenario, impact_percentage)
+            
+            return {
+                "scenario_description": scenario_data["description"],
+                "portfolio_impact": portfolio_impact,
+                "impact_percentage": impact_percentage,
+                "worst_affected_holdings": worst_affected,
+                "recommendations": recommendations,
+                "recovery_time_estimate": "6-12 months",
+                "hedging_suggestions": [
+                    "Consider defensive sector allocation",
+                    "Add hedge instruments like gold or bonds",
+                    "Implement stop-loss orders for high-risk positions"
+                ]
+            }
+            
+        except Exception as e:
+            logger.error(f"Error running stress testing: {e}")
+            raise
+    
+    def _calculate_concentration_risk(self, holdings: List[Dict[str, Any]]) -> float:
+        """Calculate portfolio concentration risk using Herfindahl index"""
+        try:
+            total_value = sum(holding.get("currentValue", 0) for holding in holdings)
+            if total_value == 0:
+                return 0.0
+            
+            # Calculate weights
+            weights = [holding.get("currentValue", 0) / total_value for holding in holdings]
+            
+            # Calculate Herfindahl index
+            herfindahl_index = sum(w * w for w in weights)
+            
+            # Convert to risk score (0-100)
+            concentration_risk = herfindahl_index * 100
+            
+            return round(concentration_risk, 2)
+            
+        except Exception as e:
+            logger.error(f"Error calculating concentration risk: {e}")
+            return 50.0  # Default moderate risk
+    
+    def _calculate_sector_concentration(self, holdings: List[Dict[str, Any]]) -> Dict[str, float]:
+        """Calculate sector-wise concentration"""
+        try:
+            # Mock sector allocation (in real system would get from security master)
+            sector_mapping = {
+                "RELIANCE": "Oil & Gas",
+                "TCS": "Information Technology", 
+                "HDFC": "Banking",
+                "INFY": "Information Technology",
+                "ICICI": "Banking",
+                "WIPRO": "Information Technology"
+            }
+            
+            sector_values = {}
+            total_value = sum(holding.get("currentValue", 0) for holding in holdings)
+            
+            for holding in holdings:
+                symbol = holding.get("tradingSymbol", "")
+                sector = sector_mapping.get(symbol, "Others")
+                value = holding.get("currentValue", 0)
+                
+                if sector in sector_values:
+                    sector_values[sector] += value
+                else:
+                    sector_values[sector] = value
+            
+            # Convert to percentages
+            sector_percentages = {}
+            for sector, value in sector_values.items():
+                sector_percentages[sector] = round((value / total_value) * 100, 2) if total_value > 0 else 0
+            
+            return sector_percentages
+            
+        except Exception as e:
+            logger.error(f"Error calculating sector concentration: {e}")
+            return {}
+    
+    def _calculate_liquidity_risk(self, holdings: List[Dict[str, Any]]) -> float:
+        """Calculate portfolio liquidity risk"""
+        try:
+            # Mock liquidity scoring based on market cap and trading volume
+            total_value = sum(holding.get("currentValue", 0) for holding in holdings)
+            
+            liquidity_scores = []
+            for holding in holdings:
+                # Mock liquidity score (in real system would use actual volume data)
+                symbol = holding.get("tradingSymbol", "")
+                if symbol in ["RELIANCE", "TCS", "HDFC", "INFY"]:
+                    liquidity_score = 90  # High liquidity
+                elif symbol in ["WIPRO", "ICICI"]:
+                    liquidity_score = 70  # Medium liquidity
+                else:
+                    liquidity_score = 50  # Lower liquidity
+                
+                weight = holding.get("currentValue", 0) / total_value if total_value > 0 else 0
+                liquidity_scores.append(liquidity_score * weight)
+            
+            weighted_liquidity = sum(liquidity_scores)
+            liquidity_risk = 100 - weighted_liquidity  # Higher score = lower risk
+            
+            return round(liquidity_risk, 2)
+            
+        except Exception as e:
+            logger.error(f"Error calculating liquidity risk: {e}")
+            return 30.0  # Default moderate liquidity risk
+    
+    def _calculate_currency_risk(self, holdings: List[Dict[str, Any]]) -> float:
+        """Calculate currency risk exposure"""
+        try:
+            # For Indian equities, currency risk is generally low
+            # In real system would consider international holdings
+            
+            total_value = sum(holding.get("currentValue", 0) for holding in holdings)
+            international_exposure = 0  # Mock - no international holdings
+            
+            currency_risk = (international_exposure / total_value) * 50 if total_value > 0 else 0
+            
+            return round(currency_risk, 2)
+            
+        except Exception as e:
+            logger.error(f"Error calculating currency risk: {e}")
+            return 5.0  # Default low currency risk
+    
+    def _calculate_overall_risk_score(
+        self, 
+        concentration_risk: float, 
+        liquidity_risk: float, 
+        currency_risk: float
+    ) -> float:
+        """Calculate overall portfolio risk score"""
+        try:
+            # Weighted average of different risk components
+            weights = {
+                "concentration": 0.4,
+                "liquidity": 0.3,
+                "currency": 0.1,
+                "market": 0.2  # Mock market risk component
+            }
+            
+            market_risk = 45.0  # Mock market risk score
+            
+            overall_score = (
+                concentration_risk * weights["concentration"] +
+                liquidity_risk * weights["liquidity"] +
+                currency_risk * weights["currency"] +
+                market_risk * weights["market"]
+            )
+            
+            return round(min(overall_score, 100), 1)
+            
+        except Exception as e:
+            logger.error(f"Error calculating overall risk score: {e}")
+            return 50.0  # Default moderate risk
+    
+    def _determine_risk_level(self, risk_score: float) -> RiskLevel:
+        """Determine risk level based on risk score"""
+        if risk_score < 30:
+            return RiskLevel.LOW
+        elif risk_score < 70:
+            return RiskLevel.MEDIUM
+        else:
+            return RiskLevel.HIGH
+    
+    def _generate_risk_recommendations(
+        self, 
+        overall_risk: float, 
+        concentration_risk: float, 
+        sector_concentration: Dict[str, float]
+    ) -> List[str]:
+        """Generate risk mitigation recommendations"""
+        recommendations = []
+        
+        if overall_risk > 70:
+            recommendations.append("Portfolio has high risk. Consider immediate diversification.")
+        
+        if concentration_risk > 50:
+            recommendations.append("High concentration risk detected. Diversify across more securities.")
+        
+        # Check for sector concentration
+        for sector, percentage in sector_concentration.items():
+            if percentage > 40:
+                recommendations.append(f"Overweight in {sector} sector ({percentage}%). Consider rebalancing.")
+        
+        if overall_risk < 30:
+            recommendations.append("Portfolio appears well-diversified with low risk.")
+        elif overall_risk < 50:
+            recommendations.append("Portfolio has moderate risk levels. Monitor regularly.")
+        
+        # Add general recommendations
+        if len(recommendations) == 0:
+            recommendations.append("Portfolio risk levels are within acceptable ranges.")
+        
+        recommendations.append("Regularly review and rebalance your portfolio.")
+        recommendations.append("Consider your risk tolerance and investment horizon.")
+        
+        return recommendations[:5]  # Limit to top 5 recommendations
+    
+    def _generate_stress_test_recommendations(self, scenario: str, impact_percentage: float) -> List[str]:
+        """Generate recommendations based on stress test results"""
+        recommendations = []
+        
+        if abs(impact_percentage) > 25:
+            recommendations.append("High portfolio vulnerability detected. Consider defensive positioning.")
+        
+        if scenario == "market_crash":
+            recommendations.extend([
+                "Consider increasing cash allocation during market uncertainty",
+                "Add defensive sectors like utilities and consumer staples",
+                "Implement systematic stop-loss orders"
+            ])
+        elif scenario == "interest_rate_shock":
+            recommendations.extend([
+                "Reduce exposure to interest-sensitive sectors",
+                "Consider floating-rate instruments",
+                "Review debt component of portfolio"
+            ])
+        elif scenario == "inflation_surge":
+            recommendations.extend([
+                "Add inflation-hedged assets like commodities",
+                "Consider real estate and infrastructure exposure",
+                "Review companies with pricing power"
+            ])
+        
+        return recommendations[:5]  # Limit to top 5

services/websocket_manager.py

@@ -1,6 +1,7 @@
 """
 WebSocket Manager for Zyon Traders Backend
 Handles real-time data distribution to connected clients
+Integrates with Dhan WebSocket service for real-time market data
 """
 
 import asyncio
@@ -11,6 +12,8 @@ from fastapi import WebSocket
 from datetime import datetime
 import random
 
+from .dhan_websocket import dhan_ws_client, MarketDataUpdate, OrderUpdate, MarketDepthUpdate
+
 logger = logging.getLogger(__name__)
 
 
@@ -20,8 +23,15 @@ class WebSocketManager:
     def __init__(self):
         self.active_connections: List[WebSocket] = []
         self.subscriptions: Dict[WebSocket, Set[str]] = {}
+        self.symbol_to_instrument: Dict[str, Dict[str, str]] = {}
         self.background_task: asyncio.Task = None
         self.running = False
+        self.dhan_connected = False
+
+        # Set up Dhan WebSocket callbacks
+        dhan_ws_client.set_market_data_callback(self._on_market_data_update)
+        dhan_ws_client.set_order_update_callback(self._on_order_update)
+        dhan_ws_client.set_market_depth_callback(self._on_market_depth_update)
     
     async def connect(self, websocket: WebSocket):
         """Accept new WebSocket connection"""
@@ -42,6 +52,25 @@ class WebSocketManager:
         """Subscribe to specific symbols for real-time updates"""
         if websocket in self.subscriptions:
             self.subscriptions[websocket].update(symbols)
+
+            # Convert symbols to Dhan instruments and subscribe to Dhan WebSocket
+            instruments_to_subscribe = []
+            for symbol in symbols:
+                # Map common symbols to Dhan instrument format
+                instrument = self._get_instrument_from_symbol(symbol)
+                if instrument:
+                    self.symbol_to_instrument[symbol] = instrument
+                    instruments_to_subscribe.append(instrument)
+
+            # Subscribe to Dhan WebSocket if we have instruments
+            if instruments_to_subscribe and self.dhan_connected:
+                await dhan_ws_client.subscribe_market_data(instruments_to_subscribe)
+
+                # Also subscribe to market depth for the first few instruments (limited to 50)
+                depth_instruments = instruments_to_subscribe[:50]  # Limit to 50 for market depth
+                if depth_instruments:
+                    await dhan_ws_client.subscribe_market_depth(depth_instruments)
+
             await websocket.send_text(json.dumps({
                 "type": "subscription_success",
                 "symbols": symbols,
@@ -108,31 +137,33 @@ class WebSocketManager:
         
         while self.running:
             try:
-                # Simulate price updates
-                for symbol in symbols:
-                    # Generate realistic price movement
-                    base_price = {
-                        "NIFTY": 22000,
-                        "SENSEX": 72000,
-                        "BANKNIFTY": 47000,
-                        "RELIANCE": 2500,
-                        "TCS": 3800,
-                        "INFY": 1700,
-                        "HDFC": 1600
-                    }.get(symbol, 1000)
-                    
-                    change_percent = random.uniform(-2, 2)
-                    price = base_price * (1 + change_percent / 100)
-                    
-                    data = {
-                        "price": round(price, 2),
-                        "change": round(base_price * change_percent / 100, 2),
-                        "change_percent": round(change_percent, 2),
-                        "volume": random.randint(100000, 10000000),
-                        "last_updated": datetime.utcnow().isoformat()
-                    }
-                    
-                    await self.broadcast_to_symbol_subscribers(symbol, data)
+                # Only simulate if Dhan is not connected
+                if not self.dhan_connected:
+                    # Simulate price updates
+                    for symbol in symbols:
+                        # Generate realistic price movement
+                        base_price = {
+                            "NIFTY": 22000,
+                            "SENSEX": 72000,
+                            "BANKNIFTY": 47000,
+                            "RELIANCE": 2500,
+                            "TCS": 3800,
+                            "INFY": 1700,
+                            "HDFC": 1600
+                        }.get(symbol, 1000)
+                        
+                        change_percent = random.uniform(-2, 2)
+                        price = base_price * (1 + change_percent / 100)
+                        
+                        data = {
+                            "price": round(price, 2),
+                            "change": round(base_price * change_percent / 100, 2),
+                            "change_percent": round(change_percent, 2),
+                            "volume": random.randint(100000, 10000000),
+                            "last_updated": datetime.utcnow().isoformat()
+                        }
+                        
+                        await self.broadcast_to_symbol_subscribers(symbol, data)
                 
                 # Wait before next update
                 await asyncio.sleep(2)  # Update every 2 seconds
@@ -141,9 +172,135 @@ class WebSocketManager:
                 logger.error(f"Error in market data simulation: {e}")
                 await asyncio.sleep(5)
     
+    def _get_instrument_from_symbol(self, symbol: str) -> Dict[str, str]:
+        """Convert symbol to Dhan instrument format"""
+        # Common symbol mappings (this should be expanded based on actual requirements)
+        symbol_mappings = {
+            "NIFTY": {"security_id": "26000", "exchange_segment": "NSE_INDEX"},
+            "BANKNIFTY": {"security_id": "26009", "exchange_segment": "NSE_INDEX"},
+            "SENSEX": {"security_id": "1", "exchange_segment": "BSE_INDEX"},
+            "RELIANCE": {"security_id": "2885", "exchange_segment": "NSE_EQ"},
+            "TCS": {"security_id": "11723", "exchange_segment": "NSE_EQ"},
+            "INFY": {"security_id": "1594", "exchange_segment": "NSE_EQ"},
+            "HDFC": {"security_id": "1333", "exchange_segment": "NSE_EQ"},
+        }
+
+        return symbol_mappings.get(symbol.upper())
+
+    def _get_symbol_from_instrument(self, security_id: str, exchange_segment: str) -> str:
+        """Convert Dhan instrument back to symbol"""
+        # Reverse lookup
+        for symbol, instrument in self.symbol_to_instrument.items():
+            if (instrument["security_id"] == security_id and
+                instrument["exchange_segment"] == exchange_segment):
+                return symbol
+
+        # Fallback to security_id if no mapping found
+        return f"{exchange_segment}:{security_id}"
+
+    async def _on_market_data_update(self, update: MarketDataUpdate):
+        """Handle market data updates from Dhan WebSocket"""
+        try:
+            symbol = self._get_symbol_from_instrument(update.security_id, update.exchange_segment)
+
+            data = {
+                "security_id": update.security_id,
+                "exchange_segment": update.exchange_segment,
+                "price": update.ltp,
+                "change": update.change,
+                "change_percent": update.change_percent,
+                "volume": update.volume,
+                "open": update.open_price,
+                "high": update.high_price,
+                "low": update.low_price,
+                "close": update.close_price,
+                "total_buy_qty": update.total_buy_qty,
+                "total_sell_qty": update.total_sell_qty,
+                "timestamp": update.timestamp.isoformat()
+            }
+
+            await self.broadcast_to_symbol_subscribers(symbol, data)
+
+        except Exception as e:
+            logger.error(f"Error processing market data update: {e}")
+
+    async def _on_order_update(self, update: OrderUpdate):
+        """Handle order updates from Dhan WebSocket"""
+        try:
+            data = {
+                "type": "order_update",
+                "order_id": update.order_id,
+                "client_id": update.client_id,
+                "security_id": update.security_id,
+                "exchange_segment": update.exchange_segment,
+                "status": update.order_status,
+                "transaction_type": update.transaction_type,
+                "quantity": update.quantity,
+                "price": update.price,
+                "traded_qty": update.traded_qty,
+                "traded_price": update.traded_price,
+                "avg_traded_price": update.avg_traded_price,
+                "timestamp": update.update_datetime.isoformat()
+            }
+
+            await self.broadcast_to_all(data)
+
+        except Exception as e:
+            logger.error(f"Error processing order update: {e}")
+
+    async def _on_market_depth_update(self, update: MarketDepthUpdate):
+        """Handle market depth updates from Dhan WebSocket"""
+        try:
+            symbol = self._get_symbol_from_instrument(update.security_id, update.exchange_segment)
+
+            data = {
+                "type": "market_depth",
+                "security_id": update.security_id,
+                "exchange_segment": update.exchange_segment,
+                "bids": update.bids,
+                "asks": update.asks,
+                "timestamp": update.timestamp.isoformat()
+            }
+
+            await self.broadcast_to_symbol_subscribers(symbol, data)
+
+        except Exception as e:
+            logger.error(f"Error processing market depth update: {e}")
+
+    async def connect_to_dhan(self):
+        """Connect to Dhan WebSocket services"""
+        try:
+            # Connect to market feed
+            market_feed_connected = await dhan_ws_client.connect_market_feed()
+
+            # Connect to order updates
+            order_update_connected = await dhan_ws_client.connect_order_updates()
+
+            # Connect to market depth (optional)
+            market_depth_connected = await dhan_ws_client.connect_market_depth()
+
+            self.dhan_connected = market_feed_connected
+
+            if self.dhan_connected:
+                logger.info("Connected to Dhan WebSocket services")
+            else:
+                logger.error("Failed to connect to Dhan WebSocket services")
+
+            return self.dhan_connected
+
+        except Exception as e:
+            logger.error(f"Error connecting to Dhan WebSocket: {e}")
+            self.dhan_connected = False
+            return False
+
     async def start_background_tasks(self):
-        """Start background tasks for data simulation"""
+        """Start background tasks for data simulation and Dhan connection"""
         self.running = True
+
+        # Try to connect to Dhan WebSocket first
+        await self.connect_to_dhan()
+
+        # Start simulation task (will only simulate if Dhan is not connected)
         self.background_task = asyncio.create_task(self.simulate_market_data())
         logger.info("WebSocket background tasks started")
     

utils/cache.py

@@ -0,0 +1,259 @@
+"""
+Cache utilities for Redis and in-memory caching
+"""
+
+import logging
+import json
+from typing import Any, Optional
+from datetime import datetime, timedelta
+
+logger = logging.getLogger(__name__)
+
+# In-memory cache as fallback
+_memory_cache = {}
+_cache_timestamps = {}
+
+class MemoryCache:
+    """Simple in-memory cache implementation"""
+    
+    def __init__(self):
+        self.cache = {}
+        self.timestamps = {}
+    
+    async def get(self, key: str) -> Optional[Any]:
+        """Get value from cache"""
+        try:
+            if key in self.cache and key in self.timestamps:
+                # Check if not expired (default 5 minutes)
+                if datetime.utcnow() - self.timestamps[key] < timedelta(minutes=5):
+                    return self.cache[key]
+                else:
+                    # Remove expired entry
+                    del self.cache[key]
+                    del self.timestamps[key]
+            return None
+        except Exception as e:
+            logger.error(f"Error getting from memory cache: {e}")
+            return None
+    
+    async def set(self, key: str, value: Any) -> bool:
+        """Set value in cache"""
+        try:
+            self.cache[key] = value
+            self.timestamps[key] = datetime.utcnow()
+            return True
+        except Exception as e:
+            logger.error(f"Error setting memory cache: {e}")
+            return False
+    
+    async def setex(self, key: str, ttl: int, value: Any) -> bool:
+        """Set value with expiration time"""
+        try:
+            self.cache[key] = value
+            self.timestamps[key] = datetime.utcnow()
+            # TTL is ignored in this simple implementation
+            return True
+        except Exception as e:
+            logger.error(f"Error setting memory cache with TTL: {e}")
+            return False
+    
+    async def delete(self, key: str) -> bool:
+        """Delete key from cache"""
+        try:
+            if key in self.cache:
+                del self.cache[key]
+            if key in self.timestamps:
+                del self.timestamps[key]
+            return True
+        except Exception as e:
+            logger.error(f"Error deleting from memory cache: {e}")
+            return False
+    
+    async def exists(self, key: str) -> bool:
+        """Check if key exists in cache"""
+        try:
+            if key in self.cache and key in self.timestamps:
+                # Check if not expired
+                if datetime.utcnow() - self.timestamps[key] < timedelta(minutes=5):
+                    return True
+                else:
+                    # Remove expired entry
+                    del self.cache[key]
+                    del self.timestamps[key]
+            return False
+        except Exception as e:
+            logger.error(f"Error checking memory cache existence: {e}")
+            return False
+    
+    def clear(self):
+        """Clear all cache"""
+        self.cache.clear()
+        self.timestamps.clear()
+    
+    def size(self) -> int:
+        """Get cache size"""
+        return len(self.cache)
+
+# Global memory cache instance
+memory_cache = MemoryCache()
+
+def get_redis_client():
+    """Get Redis client (returns None if Redis not available)"""
+    try:
+        # In a real implementation, you would:
+        # import redis
+        # from config.settings import get_settings
+        # settings = get_settings()
+        # if settings.REDIS_URL:
+        #     return redis.from_url(settings.REDIS_URL)
+        
+        # For now, return None to use memory cache fallback
+        return None
+    except Exception as e:
+        logger.warning(f"Redis not available, using memory cache: {e}")
+        return None
+
+async def get_cached_data(key: str, default: Any = None) -> Any:
+    """Get data from cache with fallback to memory cache"""
+    try:
+        redis_client = get_redis_client()
+        
+        if redis_client:
+            # Try Redis first
+            try:
+                data = await redis_client.get(key)
+                if data:
+                    return json.loads(data)
+            except Exception as e:
+                logger.warning(f"Redis get error: {e}")
+        
+        # Fallback to memory cache
+        data = await memory_cache.get(key)
+        return data if data is not None else default
+        
+    except Exception as e:
+        logger.error(f"Error getting cached data: {e}")
+        return default
+
+async def set_cached_data(key: str, value: Any, ttl: int = 300) -> bool:
+    """Set data in cache with fallback to memory cache"""
+    try:
+        redis_client = get_redis_client()
+        
+        if redis_client:
+            # Try Redis first
+            try:
+                await redis_client.setex(key, ttl, json.dumps(value))
+                return True
+            except Exception as e:
+                logger.warning(f"Redis set error: {e}")
+        
+        # Fallback to memory cache
+        return await memory_cache.setex(key, ttl, value)
+        
+    except Exception as e:
+        logger.error(f"Error setting cached data: {e}")
+        return False
+
+async def delete_cached_data(key: str) -> bool:
+    """Delete data from cache"""
+    try:
+        redis_client = get_redis_client()
+        
+        if redis_client:
+            try:
+                await redis_client.delete(key)
+                return True
+            except Exception as e:
+                logger.warning(f"Redis delete error: {e}")
+        
+        # Fallback to memory cache
+        return await memory_cache.delete(key)
+        
+    except Exception as e:
+        logger.error(f"Error deleting cached data: {e}")
+        return False
+
+async def cache_exists(key: str) -> bool:
+    """Check if key exists in cache"""
+    try:
+        redis_client = get_redis_client()
+        
+        if redis_client:
+            try:
+                return await redis_client.exists(key)
+            except Exception as e:
+                logger.warning(f"Redis exists error: {e}")
+        
+        # Fallback to memory cache
+        return await memory_cache.exists(key)
+        
+    except Exception as e:
+        logger.error(f"Error checking cache existence: {e}")
+        return False
+
+def clear_all_cache():
+    """Clear all cache data"""
+    try:
+        redis_client = get_redis_client()
+        
+        if redis_client:
+            try:
+                redis_client.flushall()
+            except Exception as e:
+                logger.warning(f"Redis clear error: {e}")
+        
+        # Clear memory cache
+        memory_cache.clear()
+        logger.info("All cache cleared")
+        
+    except Exception as e:
+        logger.error(f"Error clearing cache: {e}")
+
+def get_cache_stats() -> dict:
+    """Get cache statistics"""
+    try:
+        stats = {
+            "memory_cache_size": memory_cache.size(),
+            "redis_available": get_redis_client() is not None,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+        redis_client = get_redis_client()
+        if redis_client:
+            try:
+                info = redis_client.info()
+                stats["redis_info"] = {
+                    "used_memory": info.get("used_memory_human"),
+                    "connected_clients": info.get("connected_clients"),
+                    "total_commands_processed": info.get("total_commands_processed")
+                }
+            except Exception as e:
+                logger.warning(f"Could not get Redis stats: {e}")
+        
+        return stats
+        
+    except Exception as e:
+        logger.error(f"Error getting cache stats: {e}")
+        return {"error": str(e)}
+
+# Decorator for caching function results
+def cache_result(ttl: int = 300, key_prefix: str = ""):
+    """Decorator to cache function results"""
+    def decorator(func):
+        async def wrapper(*args, **kwargs):
+            # Generate cache key
+            cache_key = f"{key_prefix}:{func.__name__}:{str(args)}:{str(sorted(kwargs.items()))}"
+            
+            # Try to get from cache
+            cached_result = await get_cached_data(cache_key)
+            if cached_result is not None:
+                return cached_result
+            
+            # Execute function and cache result
+            result = await func(*args, **kwargs)
+            await set_cached_data(cache_key, result, ttl)
+            
+            return result
+        return wrapper
+    return decorator

utils/rate_limiter.py

@@ -0,0 +1,46 @@
+"""
+Rate Limiter Utility
+Simple rate limiting for API calls
+"""
+
+import asyncio
+import time
+from typing import Dict
+from collections import deque
+
+
+class RateLimiter:
+    """Simple rate limiter using sliding window"""
+    
+    def __init__(self, calls: int, period: int):
+        """
+        Args:
+            calls: Number of calls allowed
+            period: Time period in seconds
+        """
+        self.calls = calls
+        self.period = period
+        self.requests = deque()
+        self._lock = asyncio.Lock()
+    
+    async def acquire(self):
+        """Acquire permission to make a request"""
+        async with self._lock:
+            now = time.time()
+            
+            # Remove old requests outside the window
+            while self.requests and self.requests[0] <= now - self.period:
+                self.requests.popleft()
+            
+            # Check if we can make a request
+            if len(self.requests) < self.calls:
+                self.requests.append(now)
+                return
+            
+            # Need to wait
+            sleep_time = self.requests[0] + self.period - now
+            if sleep_time > 0:
+                await asyncio.sleep(sleep_time)
+                await self.acquire()  # Recursively try again
+            else:
+                self.requests.append(now)