Strategy Management

The Strategy Module is a core component of the OpenAlgo platform that enables users to create, manage, and execute automated trading strategies through webhooks. This document provides a comprehensive overview of the strategy module's features, architecture, and usage.

Overview

The Strategy Module allows traders to:

• Create and manage trading strategies

• Configure multiple symbols per strategy

• Set up intraday and positional trading modes

• Control trading hours and auto square-off times

• Integrate with trading platforms via webhooks

• Execute trades based on external signals

Core Components

1. Strategy Blueprint (strategy.py)

The strategy blueprint handles all HTTP routes and business logic for strategy management:

• Route Management: Handles all /strategy/* endpoints

• Order Processing: Manages order queues with rate limiting

• Time Management: Handles trading hours and square-off scheduling

• Webhook Processing: Processes incoming trading signals

2. Database Models (strategy_db.py)

Two main database models manage strategy data:

Strategy Model

• id: Unique identifier

• name: Strategy name

• webhook_id: Unique UUID for webhook identification

• user_id: Associated user

• platform: Trading platform (e.g., tradingview)

• is_active: Strategy activation status

• is_intraday: Intraday/Positional mode

• trading_mode: LONG/SHORT/BOTH

• start_time: Trading start time

• end_time: Trading end time

• squareoff_time: Auto square-off time

StrategySymbolMapping Model

• Links symbols to strategies

• Configures trading parameters per symbol

• Manages exchange and product type settings

Features

1. Strategy Management

• Create new strategies

• Toggle strategy activation

• Delete strategies

• View strategy details

• Configure trading times

2. Symbol Configuration

• Add/remove symbols to strategies

• Configure quantity per symbol

• Set product type (MIS/CNC/NRML)

• Choose exchange

3. Trading Controls

• Intraday/Positional mode selection

• Trading direction control (LONG/SHORT/BOTH)

• Trading hours configuration

• Automatic square-off scheduling

4. Webhook Integration

The module processes webhook signals from trading platforms with the following format:

[BASE_URL]/strategy/webhook/[WEBHOOK_ID]

Signal Keywords:

• BUY: Long entry

• SELL: Long exit

• SHORT: Short entry

• COVER: Short cover

Rate Limiting

The module implements sophisticated rate limiting:

• Regular orders: Max 10 orders per second

• Smart orders: 1 order per second

• Separate queues for different order types

Security Features

• Session validation for all routes

• Unique webhook IDs per strategy

• User-specific strategy isolation

• API key management for trading platforms

Best Practices

1. Strategy Naming:

   • Use descriptive names

   • Include relevant indicators/timeframes

   • Follow naming conventions

2. Symbol Configuration:

   • Verify exchange and product type compatibility

   • Set appropriate position sizes

   • Test with small quantities first

3. Trading Hours:

   • Set conservative trading hours

   • Allow buffer for square-off

   • Consider market timing restrictions

4. Webhook Setup:

   • Use secure webhook URLs

   • Include proper signal keywords

   • Test signals before live trading

Error Handling

The module implements comprehensive error handling:

• Database transaction management

• Order placement retries

• Invalid signal filtering

• Rate limit compliance

Integration Points

1. Trading Platforms:

   • TradingView

   • ChartInk

   • Custom platforms (via webhook API)

2. Broker Integration:

   • Supports multiple Indian brokers

   • Product type validation per exchange

   • Order type compatibility checks

Performance Considerations

• Efficient order queue processing

• Rate limit compliance

• Database connection pooling

• Background task scheduling

TradingView Webhook Configuration

Setting Up TradingView Alerts

1. Create Alert in TradingView:

   • Go to TradingView Chart

   • Click "Alerts" icon

   • Select "Create Alert"

2. Alert Settings:

   • Name: Include signal keyword (BUY/SELL/SHORT/COVER)

   • Condition: Set your trading condition

   • Message: Configure webhook message (see format below)

   • Webhook URL: [BASE_URL]/strategy/webhook/[YOUR_WEBHOOK_ID]

Webhook Message Formats

The webhook message format varies based on the trading mode of your strategy:

1. Long Only Mode

{
    "symbol": "RELIANCE",
    "action": "BUY"  // or "SELL"
}

2. Short Only Mode

{
    "symbol": "NIFTY",
    "action": "SELL"  // or "BUY"
}

3. Both Modes (Long & Short)

{
    "symbol": "TATASTEEL",
    "action": "BUY",  // BUY/SELL
    "position_size": "1"  // Required for both modes
}

TradingView Alert Message Setup

1. Alert Message Format for Long/Short Only Mode:

{
    "symbol": "openalgo_symbol",
    "action": "{{strategy.order.action}}"
}

1. Alert Message Format for Both Modes:

{
    "symbol": "openalgo_symbol",
    "action": "{{strategy.order.action}}",
    "position_size": "{{strategy.position_size}}"
}

Signal Actions by Trading Mode

1. Long Only Mode:

   • BUY: Opens a long position

   • SELL: Closes the long position

2. Short Only Mode:

   • SELL: Opens a short position

   • BUY: Closes the short position

3. Both Modes:

   • BUY with positive position_size: Opens/Increases long position

   • SELL with positive position_size: Opens/Increases short position

   • BUY with zero position_size: Closes short position

   • SELL with zero position_size: Closes long position

Important Notes:

1. Symbol Format:

   • Use the exact symbol as configured in your strategy

   • Symbols are case-sensitive

   • Must match with the configured exchange

2. Position Size:

   • Required only for "BOTH" trading mode

   • Must be included in every webhook message for "BOTH" mode

   • Represents the desired position size

3. Action Values:

   • Must be uppercase: "BUY" or "SELL"

   • Action interpretation depends on trading mode

Sample Python Code

Here are examples of how to send webhook requests using Python:

1. Basic Long/Short Mode Example

import requests

# Inputs: host URL and webhook ID
host_url = "http://127.0.0.1:5000"
webhook_id = "ee12219c-3ce1-4a2c-a9b0-0c67c5fa7e32"

# Construct the full URL
webhook_url = f"{host_url}/strategy/webhook/{webhook_id}"

# Message to be sent
post_message = {
    "symbol": "SYMBOL",
    "action": "BUY"
}

# Send POST request
try:
    response = requests.post(webhook_url, json=post_message)
    print(f"Response Status Code: {response.status_code}")
    print(f"Response Body: {response.text}")
except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")

2. Both Mode Example

import requests

def send_strategy_signal(host_url, webhook_id, symbol, action, position_size=None):
    """
    Send a strategy signal via webhook
    
    Args:
        host_url (str): Base URL of the OpenAlgo server
        webhook_id (str): Strategy's webhook ID
        symbol (str): Trading symbol
        action (str): "BUY" or "SELL"
        position_size (int, optional): Required for BOTH mode
    """
    # Construct webhook URL
    webhook_url = f"{host_url}/strategy/webhook/{webhook_id}"
    
    # Prepare message
    post_message = {
        "symbol": symbol,
        "action": action.upper()
    }
    
    # Add position_size for BOTH mode
    if position_size is not None:
        post_message["position_size"] = str(position_size)
    
    try:
        response = requests.post(webhook_url, json=post_message)
        if response.status_code == 200:
            print(f"Signal sent successfully: {post_message}")
        else:
            print(f"Error sending signal. Status: {response.status_code}")
            print(f"Response: {response.text}")
    except requests.exceptions.RequestException as e:
        print(f"Request failed: {e}")

# Example usage
host = "http://127.0.0.1:5000"
webhook_id = "ee12219c-3ce1-4a2c-a9b0-0c67c5fa7e32"

# Long entry example (BOTH mode)
send_strategy_signal(host, webhook_id, "RELIANCE", "BUY", 1)

# Short entry example (BOTH mode)
send_strategy_signal(host, webhook_id, "NIFTY", "SELL", 1)

# Close positions example (BOTH mode)
send_strategy_signal(host, webhook_id, "RELIANCE", "SELL", 0)  # Close long
send_strategy_signal(host, webhook_id, "NIFTY", "BUY", 0)     # Close short

3. Error Handling Example

import requests
import json
from typing import Dict, Optional
from datetime import datetime

class WebhookError(Exception):
    """Custom exception for webhook errors"""
    pass

class StrategyWebhook:
    def __init__(self, host_url: str, webhook_id: str):
        self.webhook_url = f"{host_url}/strategy/webhook/{webhook_id}"
    
    def send_signal(self, 
                   symbol: str, 
                   action: str, 
                   position_size: Optional[int] = None) -> Dict:
        """
        Send a trading signal with comprehensive error handling
        
        Args:
            symbol: Trading symbol
            action: "BUY" or "SELL"
            position_size: Required for BOTH mode
        
        Returns:
            Dict containing response data
        
        Raises:
            WebhookError: If the request fails or returns non-200 status
        """
        # Validate inputs
        if action.upper() not in ["BUY", "SELL"]:
            raise ValueError("Action must be either 'BUY' or 'SELL'")
        
        # Prepare message
        message = {
            "symbol": symbol,
            "action": action.upper(),
            "timestamp": datetime.now().isoformat()
        }
        
        if position_size is not None:
            message["position_size"] = str(position_size)
        
        try:
            response = requests.post(
                self.webhook_url, 
                json=message,
                timeout=5  # 5 seconds timeout
            )
            
            # Check response status
            if response.status_code != 200:
                raise WebhookError(
                    f"Request failed with status {response.status_code}: "
                    f"{response.text}"
                )
            
            return response.json()
            
        except requests.exceptions.Timeout:
            raise WebhookError("Request timed out")
        except requests.exceptions.ConnectionError:
            raise WebhookError("Connection failed")
        except json.JSONDecodeError:
            raise WebhookError("Invalid JSON response")
        except Exception as e:
            raise WebhookError(f"Unexpected error: {str(e)}")

# Usage example
try:
    webhook = StrategyWebhook(
        "http://127.0.0.1:5000",
        "ee12219c-3ce1-4a2c-a9b0-0c67c5fa7e32"
    )
    
    # Send a signal
    result = webhook.send_signal("RELIANCE", "BUY", 1)
    print(f"Signal sent successfully: {result}")
    
except WebhookError as e:
    print(f"Webhook error: {e}")
except ValueError as e:
    print(f"Invalid input: {e}")
except Exception as e:
    print(f"Unexpected error: {e}")

How Webhook Processing Works

1. Signal Reception:

   • Webhook endpoint receives TradingView alert

   • Validates webhook ID and message format

   • Checks strategy status and trading hours

2. Order Processing:

   • Matches symbol with strategy configuration

   • Validates trading mode compatibility

   • Applies position sizing rules

   • Routes to appropriate order queue

3. Rate Limiting:

   • Regular orders: Max 10/second

   • Smart orders: 1/second

   • Queue management for order bursts

4. Position Management:

   • Tracks open positions per symbol

   • Handles partial fills

   • Manages stop-loss and target orders

   • Implements square-off rules

Best Practices for Webhook Usage

1. Alert Naming:

   • Use clear, consistent naming patterns

   • Include strategy identifier

   • Add signal type in name

2. Message Formatting:

   • Use proper JSON syntax

   • Include all required fields

   • Add custom fields for strategy-specific data

3. Error Handling:

   • Set up retry mechanism in TradingView

   • Monitor webhook delivery status

   • Implement fallback signals

4. Testing:

   • Test with paper trading first

   • Verify webhook connectivity

   • Validate all signal types

   • Check position tracking

Future Enhancements

Planned improvements include:

• Advanced order types

• Strategy templates

• Performance analytics

• Risk management features

• Multi-account support