Rsi Algo trading Bot using Python

				
					import pandas as pd
import time
import random

# Constants
symbols = ['YESBANK-EQ', 'IDFC-EQ','GMRINFRA-EQ']

# Track current positions and trades
open_trades = {}  # Dictionary to track open trades for each symbol
closed_trades = []  # List of dictionaries with closed trades

# Function to fetch historical data (demo, replace with actual data retrieval logic)
def fetch_historical_data(symbol, timeframe):
    # Mapping of symbols to actual symbols used for fetching historical data
    symbol_mapping = {
        "YESBANK-EQ": "YESBANK",
        "IDFC-EQ": "IDFC",
        "GMRINFRA-EQ": "GMRINFRA"
        # Add more mappings as needed
    }

    # Get the actual symbol from the mapping or use the input symbol if not found
    actual_symbol = symbol_mapping.get(symbol, symbol)

    # Fetch historical data using the actual symbol
    df = get_RSI_Signal_data(actual_symbol, interval=timeframe)[::-1]

    return df[0:5]


# Function to simulate fetching live price
def get_live_data(symbol):
    # Check if the symbol is in the live data dictionary
    if symbol in live_data:
        return live_data[symbol]

    # Handle specific mappings for demo purposes
    if symbol == 'YESBANK-EQ' and '11915' in live_data:
        return float(live_data['11915'])
    elif symbol == 'IDFC-EQ' and '11957' in live_data:
        return float(live_data['11957'])
    elif symbol == 'GMRINFRA-EQ' and '13528' in live_data:
        return float(live_data['13528'])
    return None

# Function to check for stop-loss and sell conditions for all symbols
def check_stop_loss():
    global open_trades
    symbols_to_remove = []

    for symbol in open_trades.keys():
        if stop_loss_condition_met(symbol):
            # Close the position
            sell = place_sell_order_with_retry(symbol, 1, open_trades)

            closed_trade = {
                'symbol': symbol,
                'entry_price': open_trades[symbol]['entry_price'],
                'exit_price': sell,  
                'pnl': sell - open_trades[symbol]['entry_price']
            }
            closed_trades.append(closed_trade)
            symbols_to_remove.append(symbol)  # Reset position after selling
    for symbol in symbols_to_remove:
        open_trades.pop(symbol, None) 

# Function to check for target conditions for all symbols
def check_target():
    global open_trades
    symbols_to_remove = []

    for symbol in open_trades.keys():
        if target_condition_met(symbol):

            sell=place_sell_order_with_retry(symbol, 1, open_trades)

            closed_trade = {
                'symbol': symbol,
                'entry_price': open_trades[symbol]['entry_price'],
                'exit_price': sell,  
                'pnl': sell - open_trades[symbol]['entry_price']
            }
            closed_trades.append(closed_trade)
            symbols_to_remove.append(symbol)  # Reset position after selling
    for symbol in symbols_to_remove:
        open_trades.pop(symbol, None)


def stop_loss_condition_met(symbol):

    live_price = float(get_live_data(symbol))
    entry_price = open_trades[symbol]['entry_price']
    stop_loss = open_trades[symbol]['stop_loss']

    return live_price < stop_loss


def target_condition_met(symbol):

    live_price = float(get_live_data(symbol))
    entry_price = open_trades[symbol]['entry_price']
    target = open_trades[symbol]['target']

    return live_price > target

# Main trading loop
def main():
    global open_trades, closed_trades

    while True:
        for symbol in symbols:
            # Fetch historical data
            historical_data = fetch_historical_data(symbol, timeframe='minute')

            # Extract the latest signal from the 'crossover' column
            latest_signal = historical_data['crossover_signal'].iloc[-1]
            print(latest_signal)
            #latest_signal = 1
            # Execute buy and sell orders based on the latest signal
            if latest_signal == 1 and open_trades.get(symbol) is None:
                buy = place_buy_order_with_retry(symbol, quantity=1)
                if buy == False:
                    break
                entry_price = float(buy)
                stop_loss = round((buy*.998),2)
                target = round((buy*1.002),2)
                open_trades[symbol] = {
                    'position': 'BUY',
                    'entry_price': entry_price,
                    'stop_loss': stop_loss,
                    'target': target
                }

        # Check stop-loss and target conditions for all open trades
        check_stop_loss()
        check_target()

        # Print open trades and closed trades for demo purposes
        print("Open Trades:", open_trades)
        print("Closed Trades:", closed_trades)
        print("--------------------")

        # Sleep for a specified interval before the next iteration
        time.sleep(1)  # Sleep for 5 minutes, adjust as needed

# Run the main function
if __name__ == "__main__":
    main()