♟️Available Strategies

Our Telegram bot offers a variety of pre-defined trading strategies suitable for different trading styles and market conditions.

1. RSI (Relative Strength Index)

• Overview: RSI is a momentum oscillator that measures the speed and change of price movements.

• Ideal For: Identifying overbought or oversold conditions in a trading asset.

• Usage: Typically, an RSI above 70 indicates an asset is overbought, while below 30 suggests it is oversold.

def compute_rsi(data, period=14):
    """Compute the RSI for a given data set and RSI period."""
    delta = data['close'].diff()
    gain = (delta.where(delta > 0, 0)).fillna(0)
    loss = (-delta.where(delta < 0, 0)).fillna(0)

    avg_gain = gain.rolling(window=period).mean()
    avg_loss = loss.rolling(window=period).mean()

    rs = avg_gain / avg_loss
    rsi = 100 - (100 / (1 + rs))
    return rsi

def generate_rsi_signals(data, rsi):
    """Generate buy and sell signals based on RSI."""
    data['buy_signal'] = rsi < 30   # RSI below 30 indicates oversold conditions
    data['sell_signal'] = rsi > 70  # RSI above 70 indicates overbought conditions
    return data

def get_current_rsi_trade_signal(df):
    """
    Determine the current trade signal based on the RSI strategy.

    Args:
    df (pandas.DataFrame): The DataFrame containing the price data and RSI values.

    Returns:
    str: 'BUY' if buying conditions are met, 'SELL' if selling conditions are met, 
         or None if conditions for neither are met.
    """
    if df.empty:
        return None

    current_rsi = df['rsi'].iloc[-1]
    rsi_buy_threshold = 30
    rsi_sell_threshold = 70

    if current_rsi < rsi_buy_threshold:
        return 'BUY'
    elif current_rsi > rsi_sell_threshold:
        return 'SELL'
    else:
        return None

2. MACD (Moving Average Convergence Divergence)

• Overview: MACD is a trend-following momentum indicator that shows the relationship between two moving averages of an asset's price.

• Ideal For: Spotting changes in the strength, direction, momentum, and duration of a trend.

• Usage: Traders look for signal line crossovers, centerline crossovers, and divergences to identify potential trading opportunities.

def compute_macd(data, short_window=12, long_window=26, signal_window=9):
    """Compute the MACD (Moving Average Convergence Divergence)."""
    short_ema = data['close'].ewm(span=short_window, adjust=False).mean()
    long_ema = data['close'].ewm(span=long_window, adjust=False).mean()
    macd = short_ema - long_ema
    signal = macd.ewm(span=signal_window, adjust=False).mean()
    return macd, signal

def generate_macd_signals(data, macd, signal):
    """Generate buy and sell signals based on MACD."""
    data['macd'] = macd
    data['signal_line'] = signal
    data['buy_signal'] = (macd > signal) & (macd.shift(1) <= signal.shift(1))  # MACD crosses above signal line
    data['sell_signal'] = (macd < signal) & (macd.shift(1) >= signal.shift(1))  # MACD crosses below signal line
    return data

def get_current_macd_trade_signal(df):
    """
    Determine the current trade signal based on the MACD strategy.

    Args:
    df (pandas.DataFrame): The DataFrame containing the price data and MACD values.

    Returns:
    str: 'BUY' if buying conditions are met, 'SELL' if selling conditions are met, 
         or None if conditions for neither are met.
    """
    if df.empty:
        return None

    if df['buy_signal'].iloc[-1]:
        return 'BUY'
    elif df['sell_signal'].iloc[-1]:
        return 'SELL'
    else:
        return None

3. Guppy Multiple Moving Average (GMMA)

• Overview: Guppy is an indicator used to identify trends, changes in trends, and the strength of these trends.

• Ideal For: Understanding both short-term and long-term trends and their convergence.

• Usage: The GMMA consists of two sets of moving averages – a short-term set and a long-term set. The interaction between the two sets is used for trading signals.

def compute_gmma(data):
    # Short-term EMAs
    short_term_periods = [3, 5, 8, 10, 12, 15]
    for period in short_term_periods:
        data[f'Ema_{period}'] = data['close'].ewm(span=period, adjust=False).mean()

    # Long-term EMAs
    long_term_periods = [30, 35, 40, 45, 50, 60]
    for period in long_term_periods:
        data[f'Ema_{period}'] = data['close'].ewm(span=period, adjust=False).mean()

    return data

def generate_gmma_signals(data):
    short_term = data[['Ema_3', 'Ema_5', 'Ema_8', 'Ema_10', 'Ema_12', 'Ema_15']].mean(axis=1)
    long_term = data[['Ema_30', 'Ema_35', 'Ema_40', 'Ema_45', 'Ema_50', 'Ema_60']].mean(axis=1)

    # Generate signals
    data['buy_signal'] = short_term > long_term
    data['sell_signal'] = short_term < long_term

    return data

def get_current_gmma_trade_signal(df):
    if df.empty:
        return None

    if df['buy_signal'].iloc[-1] and not df['buy_signal'].iloc[-2]:
        return 'BUY'
    elif df['sell_signal'].iloc[-1] and not df['sell_signal'].iloc[-2]:
        return 'SELL'
    else:
        return None

4. Bollinger Bands

Bollinger Bands are a type of price envelope developed by John Bollinger. They consist of two volatility bands placed above and below a moving average. Volatility is based on the standard deviation, which changes as volatility increases or decreases.

Ideal For: Bollinger Bands are particularly effective in trending markets where they can provide insights into potential highs and lows of an asset's price. They are used to identify overbought and oversold conditions, market volatility, and potential price breakouts.

Usage:

• Overbought Condition: When the price moves above the upper band, the asset may be considered overbought, suggesting a possible selling opportunity or a potential pullback in the price.

• Oversold Condition: Conversely, if the price drops below the lower band, the asset might be considered oversold, indicating a potential buying opportunity or a price increase.

• Volatility Analysis: The width of the bands is also used to gauge volatility. A narrow "squeeze" of the bands can indicate a period of low volatility and hint at a potential future increase in volatility and the likelihood of a significant price movement.

• Trend Identification: In a strong uptrend, prices might consistently ride the upper band, and during a downtrend, they could cling to the lower band.

def compute_bollinger(data, window=14, num_std_dev=2.5):
    """Compute Bollinger Bands for a given DataFrame."""
    rolling_mean = data['close'].rolling(window=window).mean()
    rolling_std = data['close'].rolling(window=window).std()
    upper_band = rolling_mean + (rolling_std * num_std_dev)
    lower_band = rolling_mean - (rolling_std * num_std_dev)
    return upper_band, lower_band

def generate_bollinger_signals(data, upper_band, lower_band):
    """Generate buy and sell signals based on Bollinger Bands."""
    data['upper_band'] = upper_band
    data['lower_band'] = lower_band
    data['buy_signal'] = data['close'] < data['lower_band']  # Close price crosses below lower band
    data['sell_signal'] = data['close'] > data['upper_band']  # Close price crosses above upper band
    return data

def get_current_bollinger_trade_signal(df):
    """
    Determine the current trade signal based on the Bollinger Bands strategy.

    Args:
    df (pandas.DataFrame): The DataFrame containing the price data and Bollinger Band values.

    Returns:
    str: 'BUY' if buying conditions are met, 'SELL' if selling conditions are met,
         or None if conditions for neither are met.
    """
    if df.empty:
        return None

    if df['buy_signal'].iloc[-1]:
        return 'BUY'
    elif df['sell_signal'].iloc[-1]:
        return 'SELL'
    else:
        return None

5. VWAP

```python
import pandas as pd

def compute_vwap(data, short_window=13, long_window=26, signal_window=9):
    """Compute the MACD (Moving Average Convergence Divergence)."""
    short_ema = data['close'].ewm(span=short_window, adjust=False).mean()
    long_ema = data['close'].ewm(span=long_window, adjust=False).mean()
    macd = short_ema - long_ema
    signal = macd.ewm(span=signal_window, adjust=False).mean()
    return macd, signal

def generate_vwap_signals(data, macd, signal):
    """Generate buy and sell signals based on MACD."""
    data['macd'] = macd
    data['signal_line'] = signal
    data['buy_signal'] = (macd > signal) & (macd.shift(1) <= signal.shift(1))  # MACD crosses above signal line
    data['sell_signal'] = (macd < signal) & (macd.shift(1) >= signal.shift(1))  # MACD crosses below signal line
    return data

def get_current_vwap_trade_signal(df):
    """
    Determine the current trade signal based on the MACD strategy.

    Args:
    df (pandas.DataFrame): The DataFrame containing the price data and MACD values.

    Returns:
    str: 'BUY' if buying conditions are met, 'SELL' if selling conditions are met, 
         or None if conditions for neither are met.
    """
    if df.empty:
        return None

    if df['buy_signal'].iloc[-1]:
        return 'BUY'
    elif df['sell_signal'].iloc[-1]:
        return 'SELL'
    else:
        return None

def execute_vwap(df, user_strategy_data):
    # Compute MACD and signal line
    macd, signal = compute_vwap(df)
    signals = generate_vwap_signals(df, macd, signal)

    #print(signals)
    current_trade_signal = get_current_vwap_trade_signal(df)
    #print(current_trade_signal)

    # Return both the signals and the current trade signal
    return signals, current_trade_signal
```+

6. MA Crossover

````python
import pandas as pd

def compute_ma_crossover(data):
    # Moving Averages
    data['Short_MA'] = data['close'].rolling(window=5).mean()
    data['Long_MA'] = data['close'].rolling(window=20).mean()
    return data

def generate_ma_crossover_signals(data):
    data['buy_signal'] = False
    data['sell_signal'] = False

    for i in range(1, len(data)):
        if data['Short_MA'].iloc[i] > data['Long_MA'].iloc[i] and data['Short_MA'].iloc[i-1] <= data['Long_MA'].iloc[i-1]:
            data.at[i, 'buy_signal'] = True
        elif data['Short_MA'].iloc[i] < data['Long_MA'].iloc[i] and data['Short_MA'].iloc[i-1] >= data['Long_MA'].iloc[i-1]:
            data.at[i, 'sell_signal'] = True

    return data

def get_current_ma_crossover_signal(df):
    if df.empty:
        return None

    last_buy_index = df[df['buy_signal']].index.max()
    last_sell_index = df[df['sell_signal']].index.max()

    if pd.isna(last_buy_index) and pd.isna(last_sell_index):
        return None
    elif pd.isna(last_sell_index) or (last_buy_index > last_sell_index):
        return 'BUY'
    elif pd.isna(last_buy_index) or (last_sell_index > last_buy_index):
        return 'SELL'
    else:
        return None

def execute_ma_crossover(df):
    df = compute_ma_crossover(df)
    signals = generate_ma_crossover_signals(df)

    current_trade_signal = get_current_ma_crossover_signal(df)
    return signals, current_trade_signal
```

7. Ichimoku Cloud

```python
import pandas as pd

def compute_ichimoku_cloud(data):
    """
    Calculate the Ichimoku Cloud
    :param data: DataFrame with 'high', 'low', and 'close' columns
    :return: DataFrame with Ichimoku Cloud components
    """
    high_prices = data['high']
    low_prices = data['low']
    close_prices = data['close']

    # Tenkan-sen (Conversion Line)
    data['tenkan_sen'] = (high_prices.rolling(window=9).max() + low_prices.rolling(window=9).min()) / 2

    # Kijun-sen (Base Line)
    data['kijun_sen'] = (high_prices.rolling(window=26).max() + low_prices.rolling(window=26).min()) / 2

    # Senkou Span A (Leading Span A)
    data['senkou_span_a'] = ((data['tenkan_sen'] + data['kijun_sen']) / 2).shift(26)

    # Senkou Span B (Leading Span B)
    data['senkou_span_b'] = ((high_prices.rolling(window=52).max() + low_prices.rolling(window=52).min()) / 2).shift(26)

    # Chikou Span (Lagging Span)
    data['chikou_span'] = close_prices.shift(-26)

    return data

def generate_ichimoku_signals(data):
    """
    Generate buy and sell signals based on Ichimoku Cloud
    :param data: DataFrame with Ichimoku Cloud components
    :return: DataFrame with 'buy_signal' and 'sell_signal'
    """
    data['buy_signal'] = False
    data['sell_signal'] = False
    
    last_signal = ''  # This variable will track the last signal

    for i in range(26, len(data)):
        # Buy condition
        if data['close'].iloc[i] > max(data['senkou_span_a'].iloc[i], data['senkou_span_b'].iloc[i]) and last_signal != 'buy':
            data.at[i, 'buy_signal'] = True
            data.at[i, 'sell_signal'] = False
            last_signal = 'buy'
        # Sell condition
        elif data['close'].iloc[i] < min(data['senkou_span_a'].iloc[i], data['senkou_span_b'].iloc[i]) and last_signal != 'sell':
            data.at[i, 'sell_signal'] = True
            data.at[i, 'buy_signal'] = False
            last_signal = 'sell'

    return data

def get_current_ichimoku_trade_signal(data):
    """
    Get the current trade signal based on the Ichimoku Cloud
    :param data: DataFrame with Ichimoku Cloud components and signals
    :return: The current trade signal ('buy', 'sell', or 'hold')
    """
    # Ensure there is data to analyze
    if data.empty:
        return 'hold'

    # Access the most recent row in the DataFrame
    latest_data = data.iloc[-1]

    # Determine the trade signal
    if latest_data['buy_signal']:
        return 'buy'
    elif latest_data['sell_signal']:
        return 'sell'
    else:
        return 'hold'

def execute_ichimoku_strategy(df):
    df = compute_ichimoku_cloud(df)
    signals = generate_ichimoku_signals(df)
    return signals

```

1. ATR

```python
import pandas as pd

def compute_atr(data, atr_period=14):
    """
    Calculate the Average True Range (ATR)
    :param data: DataFrame with 'high', 'low', and 'close' columns
    :param atr_period: The period over which to calculate ATR
    :return: DataFrame with 'ATR' column
    """
    data['high-low'] = data['high'] - data['low']
    data['high-close'] = abs(data['high'] - data['close'].shift())
    data['low-close'] = abs(data['low'] - data['close'].shift())
    tr = data[['high-low', 'high-close', 'low-close']].max(axis=1)
    atr = tr.rolling(window=atr_period).mean()

    data['ATR'] = atr
    return data.drop(['high-low', 'high-close', 'low-close'], axis=1)

def generate_atr_breakout_signals(data, atr_multiplier=2):
    """
    Generate buy and sell signals based on ATR Breakout
    :param data: DataFrame with 'close' and 'ATR' columns
    :param atr_multiplier: Multiplier for ATR to define breakout range
    :return: DataFrame with 'buy_signal' and 'sell_signal'
    """
    data['buy_signal'] = False
    data['sell_signal'] = False

    # Define breakout range
    data['upper_band'] = data['close'].rolling(window=20).mean() + atr_multiplier * data['ATR']
    data['lower_band'] = data['close'].rolling(window=20).mean() - atr_multiplier * data['ATR']

    for i in range(1, len(data)):
        # Buy signal: price breaks above upper band
        if data['close'].iloc[i] > data['upper_band'].iloc[i] and data['close'].iloc[i-1] <= data['upper_band'].iloc[i-1]:
            data.at[i, 'buy_signal'] = True
        # Sell signal: price breaks below lower band
        elif data['close'].iloc[i] < data['lower_band'].iloc[i] and data['close'].iloc[i-1] >= data['lower_band'].iloc[i-1]:
            data.at[i, 'sell_signal'] = True

    return data.drop(['upper_band', 'lower_band'], axis=1)

def get_current_atr_breakout_signal(data):
    """
    Get the current trade signal based on the latest ATR Breakout values
    :param data: DataFrame with 'buy_signal' and 'sell_signal'
    :return: Current trade signal ('BUY', 'SELL', or None)
    """
    if data.empty:
        return None

    last_buy_index = data[data['buy_signal']].index.max()
    last_sell_index = data[data['sell_signal']].index.max()

    if pd.isna(last_buy_index) and pd.isna(last_sell_index):
        return None
    elif pd.isna(last_sell_index) or (last_buy_index > last_sell_index):
        return 'BUY'
    elif pd.isna(last_buy_index) or (last_sell_index > last_buy_index):
        return 'SELL'
    else:
        return None

def execute_atr_breakout(df):
    df = compute_atr(df)
    signals = generate_atr_breakout_signals(df)

    current_trade_signal = get_current_atr_breakout_signal(df)
    return signals, current_trade_signal

```

We are continuously working to expand our range of strategies to cater to a broader range of trading preferences and market conditions.