Synced repo using 'sync_with_huggingface' Github Action

app.py

@@ -0,0 +1,99 @@
+import gradio as gr
+from indicators import SMC
+from utils import smc_plot_backtest, smc_ema_plot_backtest, smc_structure_plot_backtest, fetch
+import pandas as pd
+
+symbols = pd.read_csv('data/Ticker_List_NSE_India.csv')
+limits = pd.read_csv('data/yahoo_limits.csv')
+
+def run(stock, interval, period, strategy, swing_hl, ema1=9, ema2=21, cross_close=False):
+    # Downloading ticker data.
+    ticker =  symbols[symbols['NAME OF COMPANY'] == stock]['YahooEquiv'].values[0]
+    data = fetch(ticker, period, interval)
+
+    # Plotting signal plot based on strategy.
+    if strategy == "Order Block" or strategy == "Order Block with EMA":
+        signal_plot = (SMC(data=data, swing_hl_window_sz=swing_hl).
+                       plot(order_blocks=True, swing_hl=True, show=False).
+                       update_layout(title=dict(text=ticker)))
+    else:
+        signal_plot = (SMC(data=data, swing_hl_window_sz=swing_hl).
+                       plot(swing_hl_v2=True, structure=True, show=False).
+                       update_layout(title=dict(text=ticker)))
+
+    backtest_plot = gr.Plot()
+
+    # Plotting backtest plot based on strategy.
+    if strategy == "Order Block":
+        backtest_plot = smc_plot_backtest(data, 'test.html', swing_hl)
+    if strategy == "Order Block with EMA":
+        backtest_plot = smc_ema_plot_backtest(data, 'test.html', ema1, ema2, cross_close)
+    if strategy == "Structure trading":
+        backtest_plot = smc_structure_plot_backtest(data, 'test.html', swing_hl)
+
+    return signal_plot, backtest_plot
+
+
+with gr.Blocks(fill_width=True) as app:
+    gr.Markdown(
+        '# Algorithmic Trading Dashboard'
+    )
+    stock = gr.Dropdown(symbols['NAME OF COMPANY'].unique().tolist(), label='Select Company', value=None)
+
+    with gr.Row():
+        interval = gr.Dropdown(limits['interval'].tolist(), label='Select Interval', value=None)
+
+        period_list = ['1d', '5d', '1mo', '3mo', '6mo', '1y', '2y', '5y', '10y', 'ytd', 'max']
+        period = gr.Dropdown(label = 'Select Period', choices=["max"], value="max")
+
+        # Updating period based on interval
+        def update_period(interval):
+            limit = limits[limits['interval'] == interval]['limit'].values[0]
+            idx = period_list.index(limit)
+            return gr.Dropdown(period_list[:idx+1]+['max'], interactive=True, label='Select Period')
+
+        interval.change(update_period, [interval], [period])
+
+    with gr.Row():
+        strategy = gr.Dropdown(['Order Block', 'Order Block with EMA', 'Structure trading'], label='Strategy', value=None)
+        swing_hl = gr.Number(label="Swing High/Low Window Size", value=10, interactive=True)
+
+    @gr.render(inputs=[strategy])
+    def show_extra(strat):
+        if strat == "Order Block with EMA":
+            with gr.Row():
+                ema1 = gr.Number(label='Fast EMA length', value=9)
+                ema2 = gr.Number(label='Slow EMA length', value=21)
+                cross_close = gr.Checkbox(label='Close trade on EMA crossover')
+            input = [stock, interval, period, strategy, swing_hl, ema1, ema2, cross_close]
+
+        elif strat == "Order Block" or strat == "Structure trading":
+            input = [stock, interval, period, strategy, swing_hl]
+        else:
+            input = []
+
+        btn.click(
+            run,
+            inputs=input,
+            outputs=[signal_plot, backtest_plot]
+        )
+
+        examples = gr.Examples(
+            examples=[
+                ["Reliance Industries Limited", "15m", "max", "Order Block", 10],
+                ["Reliance Industries Limited", "15m", "max", "Order Block with EMA", 10],
+                ["Reliance Industries Limited", "15m", "max", "Structure trading", 20],
+            ],
+            example_labels=['Order Block', 'Order Block with EMA', 'Structure trading'],
+            inputs=[stock, interval, period, strategy, swing_hl]
+        )
+
+    btn = gr.Button("Run")
+
+    with gr.Row():
+        signal_plot = gr.Plot(label='Signal plot')
+
+    with gr.Row():
+        backtest_plot = gr.Plot(label='Backtesting plot')
+
+app.launch(debug=True)

data/ind_nifty50list.csv

@@ -0,0 +1,52 @@
+Company Name,Industry,Symbol,Series,ISIN Code
+Adani Enterprises Ltd.,Metals & Mining,ADANIENT,EQ,INE423A01024
+Adani Ports and Special Economic Zone Ltd.,Services,ADANIPORTS,EQ,INE742F01042
+Apollo Hospitals Enterprise Ltd.,Healthcare,APOLLOHOSP,EQ,INE437A01024
+Asian Paints Ltd.,Consumer Durables,ASIANPAINT,EQ,INE021A01026
+Axis Bank Ltd.,Financial Services,AXISBANK,EQ,INE238A01034
+Bajaj Auto Ltd.,Automobile and Auto Components,BAJAJ-AUTO,EQ,INE917I01010
+Bajaj Finance Ltd.,Financial Services,BAJFINANCE,EQ,INE296A01024
+Bajaj Finserv Ltd.,Financial Services,BAJAJFINSV,EQ,INE918I01026
+Bharat Electronics Ltd.,Capital Goods,BEL,EQ,INE263A01024
+Bharat Petroleum Corporation Ltd.,Oil Gas & Consumable Fuels,BPCL,EQ,INE029A01011
+Bharti Airtel Ltd.,Telecommunication,BHARTIARTL,EQ,INE397D01024
+Britannia Industries Ltd.,Fast Moving Consumer Goods,BRITANNIA,EQ,INE216A01030
+Cipla Ltd.,Healthcare,CIPLA,EQ,INE059A01026
+Coal India Ltd.,Oil Gas & Consumable Fuels,COALINDIA,EQ,INE522F01014
+Dr. Reddy's Laboratories Ltd.,Healthcare,DRREDDY,EQ,INE089A01031
+Dummy ITC Ltd.,Consumer Services,DUMMYITC,EQ,DUM154A01025
+Eicher Motors Ltd.,Automobile and Auto Components,EICHERMOT,EQ,INE066A01021
+Grasim Industries Ltd.,Construction Materials,GRASIM,EQ,INE047A01021
+HCL Technologies Ltd.,Information Technology,HCLTECH,EQ,INE860A01027
+HDFC Bank Ltd.,Financial Services,HDFCBANK,EQ,INE040A01034
+HDFC Life Insurance Company Ltd.,Financial Services,HDFCLIFE,EQ,INE795G01014
+Hero MotoCorp Ltd.,Automobile and Auto Components,HEROMOTOCO,EQ,INE158A01026
+Hindalco Industries Ltd.,Metals & Mining,HINDALCO,EQ,INE038A01020
+Hindustan Unilever Ltd.,Fast Moving Consumer Goods,HINDUNILVR,EQ,INE030A01027
+ICICI Bank Ltd.,Financial Services,ICICIBANK,EQ,INE090A01021
+ITC Ltd.,Fast Moving Consumer Goods,ITC,EQ,INE154A01025
+IndusInd Bank Ltd.,Financial Services,INDUSINDBK,EQ,INE095A01012
+Infosys Ltd.,Information Technology,INFY,EQ,INE009A01021
+JSW Steel Ltd.,Metals & Mining,JSWSTEEL,EQ,INE019A01038
+Kotak Mahindra Bank Ltd.,Financial Services,KOTAKBANK,EQ,INE237A01028
+Larsen & Toubro Ltd.,Construction,LT,EQ,INE018A01030
+Mahindra & Mahindra Ltd.,Automobile and Auto Components,M&M,EQ,INE101A01026
+Maruti Suzuki India Ltd.,Automobile and Auto Components,MARUTI,EQ,INE585B01010
+NTPC Ltd.,Power,NTPC,EQ,INE733E01010
+Nestle India Ltd.,Fast Moving Consumer Goods,NESTLEIND,EQ,INE239A01024
+Oil & Natural Gas Corporation Ltd.,Oil Gas & Consumable Fuels,ONGC,EQ,INE213A01029
+Power Grid Corporation of India Ltd.,Power,POWERGRID,EQ,INE752E01010
+Reliance Industries Ltd.,Oil Gas & Consumable Fuels,RELIANCE,EQ,INE002A01018
+SBI Life Insurance Company Ltd.,Financial Services,SBILIFE,EQ,INE123W01016
+Shriram Finance Ltd.,Financial Services,SHRIRAMFIN,EQ,INE721A01047
+State Bank of India,Financial Services,SBIN,EQ,INE062A01020
+Sun Pharmaceutical Industries Ltd.,Healthcare,SUNPHARMA,EQ,INE044A01036
+Tata Consultancy Services Ltd.,Information Technology,TCS,EQ,INE467B01029
+Tata Consumer Products Ltd.,Fast Moving Consumer Goods,TATACONSUM,EQ,INE192A01025
+Tata Motors Ltd.,Automobile and Auto Components,TATAMOTORS,EQ,INE155A01022
+Tata Steel Ltd.,Metals & Mining,TATASTEEL,EQ,INE081A01020
+Tech Mahindra Ltd.,Information Technology,TECHM,EQ,INE669C01036
+Titan Company Ltd.,Consumer Durables,TITAN,EQ,INE280A01028
+Trent Ltd.,Consumer Services,TRENT,EQ,INE849A01020
+UltraTech Cement Ltd.,Construction Materials,ULTRACEMCO,EQ,INE481G01011
+Wipro Ltd.,Information Technology,WIPRO,EQ,INE075A01022

data/yahoo_limits.csv

@@ -0,0 +1,12 @@
+interval,limit
+1m,5d
+2m,1mo
+5m,1mo
+15m,1mo
+30m,1mo
+1h,2y
+1d,ytd
+5d,ytd
+1wk,ytd
+1mo,ytd
+3mo,ytd

indicators.py

@@ -0,0 +1,630 @@
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+class SMC:
+    def __init__(self, data, swing_hl_window_sz=10):
+        """
+        Smart Money Concept
+        :param data:
+            Should contain Open, High, Low, Close columns and 'Date' as index.
+        :type data: pd.DataFrame
+        :param swing_hl_window_sz: {int}
+            CHoCH Detection Period.
+        """
+        self.data = data
+        self.data['Date'] = self.data.index.to_series()
+        self.swing_hl_window_sz = swing_hl_window_sz
+        self.order_blocks = self.order_block()
+        self.swing_hl = self.swing_highs_lows_v2(self.swing_hl_window_sz)
+        self.structure_map = self.bos_choch(self.swing_hl)
+
+    def backtest_buy_signal_ob(self):
+        """
+        :return:
+            Get buy signals from order blocks mitigation index.
+        :rtype: np.ndarray
+        """
+        # Get only bullish order blocks which are mitigated.
+        bull_ob = self.order_blocks[(self.order_blocks['OB']==1) & (self.order_blocks['MitigatedIndex']!=0)]
+        arr = np.zeros(len(self.data))
+        # Mark the mitigated indices with 1.
+        arr[bull_ob['MitigatedIndex'].apply(lambda x: int(x))] = 1
+        return arr
+
+    def backtest_sell_signal_ob(self):
+        """
+        :return:
+            Get sell signals from order blocks mitigation index.
+        :rtype: np.ndarray
+        """
+        # Get only bearish order blocks which are mitigated.
+        bear_ob = self.order_blocks[(self.order_blocks['OB'] == -1) & (self.order_blocks['MitigatedIndex'] != 0)]
+        arr = np.zeros(len(self.data))
+        # Mark the mitigated indices with -1.
+        arr[bear_ob['MitigatedIndex'].apply(lambda x: int(x))] = -1
+        return arr
+
+    def backtest_buy_signal_structure(self):
+        """
+        :return:
+            Get buy signals from bullish structure broken index.
+        :rtype: np.ndarray
+        """
+        # Get only bullish structure.
+        bull_struct = self.structure_map[(self.structure_map['BOS'] == 1) | (self.structure_map['CHOCH'] == 1)]
+        arr = np.zeros(len(self.data))
+        # Mark the broken indices with 1.
+        arr[bull_struct['BrokenIndex'].apply(lambda x: int(x))] = 1
+        return arr
+
+    def backtest_sell_signal_structure(self):
+        """
+        :return:
+            Get buy signals from bullish structure broken index.
+        :rtype: np.ndarray
+        """
+        # Get only bearish structure.
+        bull_struct = self.structure_map[(self.structure_map['BOS'] == -1) | (self.structure_map['CHOCH'] == -1)]
+        arr = np.zeros(len(self.data))
+        # Mark the broken indices with -1.
+        arr[bull_struct['BrokenIndex'].apply(lambda x: int(x))] = 1
+        return arr
+
+    def swing_highs_lows(self, window_size):
+        """
+        Basic version of swing highs and lows. Suitable for finding swing order blocks.
+        :param window_size:
+            Window size for searching swing highs and lows
+        :type window_size: int
+        :return:
+            DataFrame with Date, highs(bool), lows(bool) columns
+        :rtype: pd.DataFrame
+        """
+        l = self.data['Low'].reset_index(drop=True)
+        h = self.data['High'].reset_index(drop=True)
+        swing_highs = (h.rolling(window_size, center=True).max() / h == 1.)
+        swing_lows = (l.rolling(window_size, center=True).min() / l == 1.)
+        return pd.DataFrame({'Date':self.data.index.to_series(), 'highs':swing_highs.values, 'lows':swing_lows.values})
+
+    def swing_highs_lows_v2(self, window_size):
+        """
+        Updated version of swing_highs_lows function. Suitable for BOS and CHoCH.
+        :param window_size:
+            Window size for searching swing highs and lows.
+        :type window_size: int
+        :return:
+            DataFrame with HighLow(1 for bull, -1 for bear), Level columns.
+        :rtype: pd.DataFrame
+        """
+        # Reversing the datapoints for .rolling() method with right to left.
+        l = self.data['Low'][::-1].reset_index(drop=True)
+        h = self.data['High'][::-1].reset_index(drop=True)
+        swing_highs = (h.rolling(window_size, min_periods=1).max() / h == 1.)[::-1]
+        swing_lows = (l.rolling(window_size, min_periods=1).min() / l == 1.)[::-1]
+
+        swing_highs.reset_index(drop=True, inplace=True)
+        swing_lows.reset_index(drop=True, inplace=True)
+
+        # Mark swing highs as 1 and swing lows as -1.
+        swings = np.where((swing_highs | swing_lows), np.where(swing_highs, 1, -1), 0)
+
+        # Filtering only one swing high between two swing lows and vice-versa.
+        state = 1
+        for i in range(1, swings.shape[0]):
+            if swings[i] == state or swings[i] == 0:
+                swings[i] = 0
+            else:
+                state *= -1
+
+        # Replace 0 with NaN.
+        swing_highs_lows = np.where(swings==0, np.nan, swings)
+
+        # Get positions of swing_highs_lows where elements are not np.nan
+        pos = np.where(~np.isnan(swing_highs_lows))[0]
+
+        # Set first position and last position of swing_highs_lows.
+        if len(pos) > 0:
+            if swing_highs_lows[pos[0]] == 1:
+                swing_highs_lows[0] = -1
+            if swing_highs_lows[pos[0]] == -1:
+                swing_highs_lows[0] = 1
+            if swing_highs_lows[pos[-1]] == -1:
+                swing_highs_lows[-1] = 1
+            if swing_highs_lows[pos[-1]] == 1:
+                swing_highs_lows[-1] = -1
+
+        level = np.where(
+            ~np.isnan(swing_highs_lows),
+            np.where(swing_highs_lows == 1, self.data.High, self.data.Low),
+            np.nan,
+        )
+
+        return pd.concat(
+            [
+                pd.Series(swing_highs_lows, name="HighLow"),
+                pd.Series(level, name="Level"),
+            ],
+            axis=1,
+        )
+
+    def bos_choch(self, swing_highs_lows):
+        """
+        Break of Structure and Change of Character
+        :param swing_highs_lows: A DataFrame which contains swing highs and lows.
+            Format should be same as swing_highs_lows_v2() function.
+        :type swing_highs_lows: pd.DataFrame
+        :return: A DataFrame with BOS(1 for bear, -1 for bull),
+            CHOCH(1 for bear, -1 for bull), Level, BrokenIndex as columns.
+        :rtype: pd.DataFrame
+        """
+        level_order = []
+        highs_lows_order = []
+
+        bos = np.zeros(len(self.data), dtype=np.int32)
+        choch = np.zeros(len(self.data), dtype=np.int32)
+        level = np.zeros(len(self.data), dtype=np.float32)
+
+        last_positions = []
+
+        for i in range(len(swing_highs_lows["HighLow"])):
+            if not np.isnan(swing_highs_lows["HighLow"][i]):
+                level_order.append(swing_highs_lows["Level"][i])
+                highs_lows_order.append(swing_highs_lows["HighLow"][i])
+                if len(level_order) >= 4:
+                    # bullish bos
+                    #                   -1
+                    #        -3 __BOS__ / \
+                    #        / \       /   \
+                    #       /   \     /
+                    #  \   /     \   /
+                    #   \ /        -2
+                    #   -4
+                    bos[last_positions[-2]] = (
+                        1
+                        if (
+                            np.all(highs_lows_order[-4:] == [-1, 1, -1, 1])
+                            and np.all(
+                                level_order[-4]
+                                < level_order[-2]
+                                < level_order[-3]
+                                < level_order[-1]
+                            )
+                        )
+                        else 0
+                    )
+                    level[last_positions[-2]] = (
+                        level_order[-3] if bos[last_positions[-2]] !=0 else 0
+                    )
+
+                    # bearish bos
+                    #   -4
+                    #   / \        -2
+                    #  /   \       / \
+                    #       \     /   \
+                    #        \   /     \
+                    #         \ /__BOS__\   /
+                    #         -3         \ /
+                    #                     -1
+                    bos[last_positions[-2]] = (
+                        -1
+                        if(
+                            np.all(highs_lows_order[-4:] == [1, -1, 1, -1])
+                            and np.all(
+                                level_order[-4]
+                                > level_order[-2]
+                                > level_order[-3]
+                                > level_order[-1]
+                            )
+                        )
+                        else bos[last_positions[-2]]
+                    )
+                    level[last_positions[-2]] = (
+                        level_order[-3] if bos[last_positions[-2]] != 0 else 0
+                    )
+
+                    # bullish CHoCH
+                    #                     -1
+                    #        -3 __CHoCH__ / \
+                    #        / \         /   \
+                    #       /   \       /
+                    #  \   /     \     /
+                    #   \ /       \   /
+                    #    -4        \ /
+                    #               -2
+                    choch[last_positions[-2]] = (
+                        1
+                        if (
+                                np.all(highs_lows_order[-4:] == [-1, 1, -1, 1])
+                                and np.all(
+                            level_order[-1]
+                            > level_order[-3]
+                            > level_order[-4]
+                            > level_order[-2]
+                        )
+                        )
+                        else 0
+                    )
+                    level[last_positions[-2]] = (
+                        level_order[-3]
+                        if choch[last_positions[-2]] != 0
+                        else level[last_positions[-2]]
+                    )
+
+                    # bearish CHoCH
+                    #              -2
+                    #   -4         / \
+                    #   / \       /   \
+                    #  /   \     /     \
+                    #       \   /       \
+                    #        \ /         \
+                    #         -3__CHoCH__ \   /
+                    #                      \ /
+                    #                       -1
+                    choch[last_positions[-2]] = (
+                        -1
+                        if (
+                                np.all(highs_lows_order[-4:] == [1, -1, 1, -1])
+                                and np.all(
+                            level_order[-1]
+                            < level_order[-3]
+                            < level_order[-4]
+                            < level_order[-2]
+                        )
+                        )
+                        else choch[last_positions[-2]]
+                    )
+                    level[last_positions[-2]] = (
+                        level_order[-3]
+                        if choch[last_positions[-2]] != 0
+                        else level[last_positions[-2]]
+                    )
+
+                last_positions.append(i)
+
+        broken = np.zeros(len(self.data), dtype=np.int32)
+        for i in np.where(np.logical_or(bos != 0, choch != 0))[0]:
+            mask = np.zeros(len(self.data), dtype=np.bool_)
+            # if the bos is 1 then check if the candles high has gone above the level
+            if bos[i] == 1 or choch[i] == 1:
+                mask = self.data.Close[i + 2:] > level[i]
+            # if the bos is -1 then check if the candles low has gone below the level
+            elif bos[i] == -1 or choch[i] == -1:
+                mask = self.data.Close[i + 2:] < level[i]
+            if np.any(mask):
+                j = np.argmax(mask) + i + 2
+                broken[i] = j
+                # if there are any unbroken bos or CHoCH that started before this one and ended after this one then remove them
+                for k in np.where(np.logical_or(bos != 0, choch != 0))[0]:
+                    if k < i and broken[k] >= j:
+                        bos[k] = 0
+                        choch[k] = 0
+                        level[k] = 0
+
+        # remove the ones that aren't broken
+        for i in np.where(
+                np.logical_and(np.logical_or(bos != 0, choch != 0), broken == 0)
+        )[0]:
+            bos[i] = 0
+            choch[i] = 0
+            level[i] = 0
+
+        # replace all the 0s with np.nan
+        bos = np.where(bos != 0, bos, np.nan)
+        choch = np.where(choch != 0, choch, np.nan)
+        level = np.where(level != 0, level, np.nan)
+        broken = np.where(broken != 0, broken, np.nan)
+
+        bos = pd.Series(bos, name="BOS")
+        choch = pd.Series(choch, name="CHOCH")
+        level = pd.Series(level, name="Level")
+        broken = pd.Series(broken, name="BrokenIndex")
+
+        return pd.concat([bos, choch, level, broken], axis=1)
+
+    def fvg(self):
+        """
+        FVG - Fair Value Gap
+        A fair value gap is when the previous high is lower than the next low if the current candle is bullish.
+        Or when the previous low is higher than the next high if the current candle is bearish.
+
+        :return:\
+        FVG = 1 if bullish fair value gap, -1 if bearish fair value gap
+        Top = the top of the fair value gap
+        Bottom = the bottom of the fair value gap
+        MitigatedIndex = the index of the candle that mitigated the fair value gap
+        :rtype: pd.DataFrame
+        """
+
+        fvg = np.where(
+            (
+                    (self.data["High"].shift(1) < self.data["Low"].shift(-1))
+                    & (self.data["Close"] > self.data["Open"])
+            )
+            | (
+                    (self.data["Low"].shift(1) > self.data["High"].shift(-1))
+                    & (self.data["Close"] < self.data["Open"])
+            ),
+            np.where(self.data["Close"] > self.data["Open"], 1, -1),
+            np.nan,
+        )
+
+        top = np.where(
+            ~np.isnan(fvg),
+            np.where(
+                self.data["Close"] > self.data["Open"],
+                self.data["Low"].shift(-1),
+                self.data["Low"].shift(1),
+            ),
+            np.nan,
+        )
+
+        bottom = np.where(
+            ~np.isnan(fvg),
+            np.where(
+                self.data["Close"] > self.data["Open"],
+                self.data["High"].shift(1),
+                self.data["High"].shift(-1),
+            ),
+            np.nan,
+        )
+
+        mitigated_index = np.zeros(len(self.data), dtype=np.int32)
+        for i in np.where(~np.isnan(fvg))[0]:
+            mask = np.zeros(len(self.data), dtype=np.bool_)
+            if fvg[i] == 1:
+                mask = self.data["Low"][i + 2:] <= top[i]
+            elif fvg[i] == -1:
+                mask = self.data["High"][i + 2:] >= bottom[i]
+            if np.any(mask):
+                j = np.argmax(mask) + i + 2
+                mitigated_index[i] = j
+
+        mitigated_index = np.where(np.isnan(fvg), np.nan, mitigated_index)
+
+        return pd.concat(
+            [
+                pd.Series(fvg.flatten(), name="FVG"),
+                pd.Series(top.flatten(), name="Top"),
+                pd.Series(bottom.flatten(), name="Bottom"),
+                pd.Series(mitigated_index.flatten(), name="MitigatedIndex"),
+            ],
+            axis=1,
+        )
+
+    def order_block(self, imb_perc=.1, join_consecutive=True):
+        """
+        OB - Order Block
+        Order block is the presence of a chunk of market orders that results in a sudden rise or fall in the market
+
+        :return:\
+        OB = 1 if bullish order block, -1 if bearish order block
+        Top = the top of the order block
+        Bottom = the bottom of the order block
+        MitigatedIndex = the index of the candle that mitigated the order block
+        :rtype: pd.DataFrame
+        """
+        hl = self.swing_highs_lows(self.swing_hl_window_sz)
+
+        ob = np.where(
+            (
+                    ((self.data["High"]*((100+imb_perc)/100)) < self.data["Low"].shift(-2))
+                    & ((hl['lows']==True) | (hl['lows'].shift(1)==True))
+            )
+            | (
+                    (self.data["Low"] > (self.data["High"].shift(-2)*((100+imb_perc)/100)))
+                    & ((hl['highs']==True) | (hl['highs'].shift(1)==True))
+            ),
+            np.where(((hl['lows']==True) | (hl['lows'].shift(1)==True)), 1, -1),
+            np.nan,
+        )
+
+        # print(ob)
+
+        top = np.where(
+            ~np.isnan(ob),
+            np.where(
+                self.data["Close"] > self.data["Open"],
+                self.data["Low"].shift(-2),
+                self.data["Low"],
+            ),
+            np.nan,
+        )
+
+        bottom = np.where(
+            ~np.isnan(ob),
+            np.where(
+                self.data["Close"] > self.data["Open"],
+                self.data["High"],
+                self.data["High"].shift(-2),
+            ),
+            np.nan,
+        )
+
+        # if join_consecutive:
+        #     for i in range(len(ob) - 1):
+        #         if ob[i] == ob[i + 1]:
+        #             top[i + 1] = max(top[i], top[i + 1])
+        #             bottom[i + 1] = min(bottom[i], bottom[i + 1])
+        #             ob[i] = top[i] = bottom[i] = np.nan
+
+        mitigated_index = np.zeros(len(self.data), dtype=np.int32)
+        for i in np.where(~np.isnan(ob))[0]:
+            mask = np.zeros(len(self.data), dtype=np.bool_)
+            if ob[i] == 1:
+                mask = self.data["Low"][i + 3:] <= top[i]
+            elif ob[i] == -1:
+                mask = self.data["High"][i + 3:] >= bottom[i]
+            if np.any(mask):
+                j = np.argmax(mask) + i + 3
+                mitigated_index[i] = int(j)
+        ob = ob.flatten()
+        mitigated_index1 = np.where(np.isnan(ob), np.nan, mitigated_index)
+
+        return pd.concat(
+            [
+                pd.Series(ob.flatten(), name="OB"),
+                pd.Series(top.flatten(), name="Top"),
+                pd.Series(bottom.flatten(), name="Bottom"),
+                pd.Series(mitigated_index1.flatten(), name="MitigatedIndex"),
+            ],
+            axis=1,
+        ).dropna(subset=['OB'])
+
+    def plot(self, order_blocks=False, swing_hl=False, swing_hl_v2=False, structure=False, show=True):
+        """
+        :param order_blocks:
+        :param swing_hl:
+        :param swing_hl_v2:
+        :param structure:
+        :param show:
+        :return:
+        """
+        fig = make_subplots(1, 1)
+
+        # plot the candle stick graph
+        fig.add_trace(go.Candlestick(x=self.data.index.to_series(),
+                        open=self.data['Open'],
+                        high=self.data['High'],
+                        low=self.data['Low'],
+                        close=self.data['Close'],
+                        name='ohlc'))
+
+        # grab first and last observations from df.date and make a continuous date range from that
+        dt_all = pd.date_range(start=self.data['Date'].iloc[0], end=self.data['Date'].iloc[-1], freq='5min')
+
+        # check which dates from your source that also accur in the continuous date range
+        dt_obs = [d.strftime("%Y-%m-%d %H:%M:%S") for d in self.data['Date']]
+
+        # isolate missing timestamps
+        dt_breaks = [d for d in dt_all.strftime("%Y-%m-%d %H:%M:%S").tolist() if not d in dt_obs]
+
+        # adjust xaxis for rangebreaks
+        fig.update_xaxes(rangebreaks=[dict(dvalue=5 * 60 * 1000, values=dt_breaks)])
+
+        if order_blocks:
+            # print(self.order_blocks.head())
+            # print(self.order_blocks.index.to_list())
+
+            ob_df = self.data.iloc[self.order_blocks.index.to_list()]
+            # print(ob_df)
+
+            fig.add_trace(go.Scatter(
+                            x=ob_df['Date'],
+                            y=ob_df['Low'],
+                            name="Order Block",
+                            mode='markers',
+                            marker_symbol='diamond-dot',
+                            marker_size=13,
+                            marker_line_width=2,
+                            # offsetgroup=0,
+                           ))
+
+        if swing_hl:
+            hl = self.swing_highs_lows(self.swing_hl_window_sz)
+            h = hl[(hl['highs']==True)]
+            l = hl[hl['lows']==True]
+
+            fig.add_trace(go.Scatter(
+                x=h['Date'],
+                y=self.data[self.data.Date.isin(h['Date'])]['High']*(100.1/100),
+                mode='markers',
+                marker_symbol="triangle-up-dot",
+                marker_size=10,
+                name='Swing High',
+                # offsetgroup=2,
+            ))
+            fig.add_trace(go.Scatter(
+                x=l['Date'],
+                y=self.data[self.data.Date.isin(l['Date'])]['Low']*(99.9/100),
+                mode='markers',
+                marker_symbol="triangle-down-dot",
+                marker_size=10,
+                name='Swing Low',
+                marker_color='red',
+                # offsetgroup=2,
+            ))
+
+        if swing_hl_v2:
+            hl = self.swing_hl
+            h = hl[hl['HighLow']==1]
+            l = hl[hl['HighLow']==-1]
+
+            fig.add_trace(go.Scatter(
+                x=self.data['Date'].iloc[h.index],
+                y=h['Level'],
+                mode='markers',
+                marker_symbol="triangle-up-dot",
+                marker_size=10,
+                name='Swing High',
+                marker_color='green',
+            ))
+            fig.add_trace(go.Scatter(
+                x=self.data['Date'].iloc[l.index],
+                y=l['Level'],
+                mode='markers',
+                marker_symbol="triangle-down-dot",
+                marker_size=10,
+                name='Swing Low',
+                marker_color='red',
+            ))
+
+        if structure:
+            struct = self.structure_map
+            struct.dropna(subset=['Level'], inplace=True)
+
+            for i in range(len(struct)):
+                x0 = self.data['Date'].iloc[struct.index[i]]
+                x1 = self.data['Date'].iloc[int(struct['BrokenIndex'].iloc[i])]
+                y = struct['Level'].iloc[i]
+                label = "BOS" if np.isnan(struct['CHOCH'].iloc[i]) else "CHOCH"
+                direction = struct[label].iloc[i]
+
+                # Add scatter trace for the line
+                fig.add_trace(go.Scatter(
+                    x=[x0, x1],  # x-coordinates of the line
+                    y=[y, y],  # y-coordinates of the line
+                    mode="lines+text",  # Line and optional label
+                    line=dict(color="blue" if label=="BOS" else "orange"),  # Customize line color
+                    text=[None, label],  # Add label only at one end
+                    textposition="top left" if direction==1 else "bottom left",  # Adjust label position
+                    name=label,  # Legend entry for this line
+                    showlegend=False
+                ))
+
+        fig.update_layout(xaxis_rangeslider_visible=False)
+        if show:
+            fig.show()
+        return fig
+
+
+def EMA(array, n):
+    """
+    :param array: price of the stock
+    :param n: window size
+    :type n: int
+    :return: Exponential moving average
+    :rtype: pd.Series
+    """
+    return pd.Series(array).ewm(span=n, adjust=False).mean()
+
+if __name__ == "__main__":
+    from utils import fetch
+
+    data = fetch('ICICIBANK.NS', period='1mo', interval='15m')
+    data = fetch('RELIANCE.NS', period='1mo', interval='15m')
+    data['Date'] = data.index.to_series()
+    filter = pd.to_datetime('2024-12-17 09:50:00.0000000011',
+               format='%Y-%m-%d %H:%M:%S.%f')
+    # data = data[data['Date']<filter]
+    # print(SMC(data).backtest_buy_signal())
+    # print(SMC(data).swing_highs_lows_v3(10).to_string())
+    # print(data.tail())
+    SMC(data).plot(order_blocks=False, swing_hl=False, swing_hl_v2=True, structure=True, show=True)
+    # struct = SMC(data).structure_map
+    # print(struct)
+    #
+    # for i in range(len(data)):
+    #     print(i, data['Date'][i], struct['BrokenIndex'].iloc[i])
+    # SMC(data).structure()

pages/complete_backtest.py

@@ -0,0 +1,55 @@
+import streamlit as st
+import pandas as pd
+from streamlit.components import v1 as components
+from utils import complete_test
+
+def complete_backtest():
+    st.title("Evaluate Strategy")
+
+    limits = pd.read_csv('data/yahoo_limits.csv')
+    period_list = ['1d', '5d', '1mo', '3mo', '6mo', '1y', '2y', '5y', '10y', 'ytd', 'max']
+
+    c1, c2 = st.columns(2)
+    with c1:
+        # Select strategy
+        strategy = st.selectbox("Select Strategy", ['Order Block', 'Order Block with EMA', 'Structure trading'], index=2)
+    with c2:
+        # Swing High/Low window size
+        swing_hl = st.number_input("Swing High/Low Window Size", min_value=1, value=10)
+
+    c1, c2 = st.columns(2)
+    with c1:
+        # Select interval
+        interval = st.selectbox("Select Interval", limits['interval'].tolist(), index=3)
+    with c2:
+        # Update period options based on interval
+        limit = limits[limits['interval'] == interval]['limit'].values[0]
+        idx = period_list.index(limit)
+        period_options = period_list[:idx + 1] + ['max']
+        period = st.selectbox("Select Period", period_options, index=3)
+
+    # EMA parameters if "Order Block with EMA" is selected
+    if strategy == "Order Block with EMA":
+        c1, c2, c3 = st.columns(3)
+        with c1:
+            ema1 = st.number_input("Fast EMA Length", min_value=1, value=9)
+        with c2:
+            ema2 = st.number_input("Slow EMA Length", min_value=1, value=21)
+        with c3:
+            cross_close = st.checkbox("Close trade on EMA crossover", value=False)
+    else:
+        ema1, ema2, cross_close = None, None, None
+
+    # Button to run the analysis
+    if st.button("Run"):
+        st.session_state.results = complete_test(strategy, period, interval, swing_hl=swing_hl, ema1=ema1, ema2=ema2, cross_close=cross_close)
+
+    if "results" in st.session_state:
+        cols = ['stock', 'Start', 'End', 'Return [%]', 'Equity Final [$]', 'Buy & Hold Return [%]', '# Trades', 'Win Rate [%]', 'Best Trade [%]', 'Worst Trade [%]', 'Avg. Trade [%]']
+        df = st.dataframe(st.session_state.results, hide_index=True, column_order=cols, on_select="rerun", selection_mode="single-row")
+        if df.selection.rows:
+            row = df.selection.rows
+            plot = st.session_state.results['plot'].values[row]
+            components.html(plot[0], height=1067)
+
+complete_backtest()

pages/dashboard.py

@@ -0,0 +1,106 @@
+import pandas as pd
+import streamlit as st
+import os
+import random
+from bokeh.io import output_file, save
+from bokeh.plotting import figure
+from streamlit.components import v1 as components
+
+from indicators import SMC
+from utils import fetch, smc_plot_backtest, smc_ema_plot_backtest, smc_structure_plot_backtest
+
+def use_file_for_bokeh(chart: figure, chart_height=1067):
+    # Function used to replace st.boken_chart, because streamlit doesn't support bokeh v3
+    file_name = f'bokeh_graph_{random.getrandbits(8)}.html'
+    output_file(file_name)
+    save(chart)
+    with open(file_name, 'r', encoding='utf-8') as f:
+        html = f.read()
+    os.remove(file_name)
+    components.html(html, height=chart_height)
+
+st.bokeh_chart = use_file_for_bokeh
+
+def algorithmic_trading_dashboard():
+    # Load data
+    symbols = pd.read_csv('data/Ticker_List_NSE_India.csv')
+    limits = pd.read_csv('data/yahoo_limits.csv')
+
+    # Dropdown options
+    period_list = ['1d', '5d', '1mo', '3mo', '6mo', '1y', '2y', '5y', '10y', 'ytd', 'max']
+
+    # Input fields on the main page
+    st.title("Algorithmic Trading Dashboard")
+
+    # Select stock
+    stock = st.selectbox("Select Company", symbols['NAME OF COMPANY'].unique(), index=None)
+
+    c1, c2 = st.columns(2)
+
+    with c1:
+        # Select interval
+        interval = st.selectbox("Select Interval", limits['interval'].tolist(), index=3)
+
+    with c2:
+        # Update period options based on interval
+        limit = limits[limits['interval'] == interval]['limit'].values[0]
+        idx = period_list.index(limit)
+        period_options = period_list[:idx + 1] + ['max']
+        period = st.selectbox("Select Period", period_options, index=3)
+
+    c1, c2 = st.columns(2)
+
+    with c1:
+        # Select strategy
+        strategy = st.selectbox("Select Strategy", ['Order Block', 'Order Block with EMA', 'Structure trading'], index=2)
+
+    with c2:
+        # Swing High/Low window size
+        swing_hl = st.number_input("Swing High/Low Window Size", min_value=1, value=10)
+
+    # EMA parameters if "Order Block with EMA" is selected
+    if strategy == "Order Block with EMA":
+        c1, c2, c3 = st.columns(3)
+        with c1:
+            ema1 = st.number_input("Fast EMA Length", min_value=1, value=9)
+        with c2:
+            ema2 = st.number_input("Slow EMA Length", min_value=1, value=21)
+        with c3:
+            cross_close = st.checkbox("Close trade on EMA crossover", value=False)
+
+    # Button to run the analysis
+    if st.button("Run"):
+        # Fetch ticker data
+        ticker = symbols[symbols['NAME OF COMPANY'] == stock]['YahooEquiv'].values[0]
+        data = fetch(ticker, period, interval)
+
+        # Generate signal plot based on strategy
+        if strategy == "Order Block" or strategy == "Order Block with EMA":
+            signal_plot = (
+                SMC(data=data, swing_hl_window_sz=swing_hl)
+                .plot(order_blocks=True, swing_hl=True, show=False)
+                .update_layout(title=dict(text=ticker))
+            )
+        else:
+            signal_plot = (
+                SMC(data=data, swing_hl_window_sz=swing_hl)
+                .plot(swing_hl_v2=True, structure=True, show=False)
+                .update_layout(title=dict(text=ticker))
+            )
+
+        # Generate backtest plot
+        if strategy == "Order Block":
+            backtest_plot = smc_plot_backtest(data, 'test.html', swing_hl)
+        elif strategy == "Order Block with EMA":
+            backtest_plot = smc_ema_plot_backtest(data, 'test.html', ema1, ema2, cross_close)
+        elif strategy == "Structure trading":
+            backtest_plot = smc_structure_plot_backtest(data, 'test.html', swing_hl)
+
+        # Display plots
+        st.write("### Signal Plot")
+        st.plotly_chart(signal_plot, width=1200)
+
+        st.write("### Backtesting Plot")
+        st.bokeh_chart(backtest_plot)
+
+algorithmic_trading_dashboard()

requirements.txt

@@ -0,0 +1,8 @@
+backtesting==0.3.3
+numpy==2.2.0
+pandas==2.2.3
+bokeh==3.1.0
+yfinance==0.2.50
+plotly==5.24.1
+gradio==5.11.0
+streamlit==1.41.1

strategies.py

@@ -0,0 +1,165 @@
+from backtesting import Backtest, Strategy
+from backtesting.lib import SignalStrategy, TrailingStrategy
+from indicators import SMC, EMA
+import pandas as pd
+import numpy as np
+
+class SMC_test(Strategy):
+    swing_window = 10
+    def init(self):
+        super().init()
+
+        # Setting smc buy and sell indicators.
+        self.smc_b = self.I(self.smc_buy, data=self.data.df, swing_hl=self.swing_window)
+        self.smc_s = self.I(self.smc_sell, data=self.data.df, swing_hl=self.swing_window)
+
+    def next(self):
+        price = self.data.Close[-1]
+        current_time = self.data.index[-1]
+
+        # If buy signal, set target 5% above price and stoploss 5% below price.
+        if self.smc_b[-1] == 1:
+            self.buy(sl=.95 * price, tp=1.05 * price)
+        # If sell signal, set targe 5% below price and stoploss 5% above price.
+        if self.smc_s[-1] == -1:
+            self.sell(tp=.95 * price, sl=1.05 * price)
+
+        # Additionally, set aggressive stop-loss on trades that have been open
+        # for more than two days
+        for trade in self.trades:
+            if current_time - trade.entry_time > pd.Timedelta('2 days'):
+                if trade.is_long:
+                    trade.sl = max(trade.sl, self.data.Low[-1])
+                else:
+                    trade.sl = min(trade.sl, self.data.High[-1])
+
+    def smc_buy(self, data, swing_hl):
+        return SMC(data, swing_hl).backtest_buy_signal_ob()
+
+    def smc_sell(self, data, swing_hl):
+        return SMC(data, swing_hl).backtest_sell_signal_ob()
+
+
+class SMC_ema(SignalStrategy, TrailingStrategy):
+    ema1 = 9
+    ema2 = 21
+    close_on_crossover = False
+
+    def init(self):
+        super().init()
+
+        # Setting smc buy and sell indicators.
+        self.smc_b = self.I(self.smc_buy, self.data.df)
+        self.smc_s = self.I(self.smc_sell, self.data.df)
+
+        close = self.data.Close
+
+        # Setting up EMAs.
+        self.ma1 = self.I(EMA, close, self.ema1)
+        self.ma2 = self.I(EMA, close, self.ema2)
+
+
+    def next(self):
+        price = self.data.Close[-1]
+        current_time = self.data.index[-1]
+
+        # If buy signal and short moving average is above long moving average.
+        if self.smc_b[-1] == 1 and self.ma1 > self.ma2:
+            self.buy(sl=.95 * price, tp=1.05 * price)
+        # If sell signal and short moving average is below long moving average.
+        if self.smc_s[-1] == -1 and self.ma1 < self.ma2:
+            self.sell(tp=.95 * price, sl=1.05 * price)
+
+        # Additionally, set aggressive stop-loss on trades that have been open
+        # for more than two days
+        for trade in self.trades:
+            if current_time - trade.entry_time > pd.Timedelta('2 days'):
+                if trade.is_long:
+                    trade.sl = max(trade.sl, self.data.Low[-1])
+                else:
+                    trade.sl = min(trade.sl, self.data.High[-1])
+
+        # Close the trade if there is a moving average crossover in opposite direction
+        if self.close_on_crossover:
+            for trade in self.trades:
+                if trade.is_long and self.ma1 < self.ma2:
+                    trade.close()
+                if trade.is_short and self.ma1 > self.ma2:
+                    trade.close()
+
+    def smc_buy(self, data):
+        return SMC(data).backtest_buy_signal_ob()
+
+    def smc_sell(self, data):
+        return SMC(data).backtest_sell_signal_ob()
+
+
+class SMCStructure(TrailingStrategy):
+    swing_window = 20
+
+    def init(self):
+        super().init()
+        self.smc_b = self.I(self.smc_buy, data=self.data.df, swing_hl=self.swing_window)
+        self.smc_s = self.I(self.smc_sell, data=self.data.df, swing_hl=self.swing_window)
+        self.set_trailing_sl(2)
+        # self.swing = self.I(self.nearest_swing, data=self.data.df, swing_hl)
+
+    def next(self):
+        price = self.data.Close[-1]
+        current_time = self.data.index[-1]
+
+        if self.smc_b[-1] == 1:
+            nearest = self.nearest_swing(self.data.df, self.swing_window)
+            target = price + ((price - nearest)* .414)
+            stoploss = price - (target-price)
+            # print(f"buy: {current_time}, {price}, {nearest}, {target}, {stoploss}")
+            try:
+                self.buy(sl=stoploss, tp=target)
+            except:
+                print('Buying failed')
+        if self.smc_s[-1] == 1:
+            nearest = self.nearest_swing(self.data.df, self.swing_window)
+            print(self.data.df.iloc[-1])
+            if nearest > price:
+                target = price - ((nearest - price) * .414)
+                stoploss = price + (price - target)
+                # print(f"sell: {current_time}, {price}, {nearest}, {target}, {stoploss}")
+                try:
+                    self.sell(sl=stoploss, tp=target, limit=float(price))
+                except:
+                    print("Selling failed")
+
+        # Additionally, set aggressive stop-loss on trades that have been open
+        # for more than two days
+        for trade in self.trades:
+            if current_time - trade.entry_time > pd.Timedelta('2 days'):
+                if trade.is_long:
+                    trade.sl = max(trade.sl, self.data.Low[-1])
+                else:
+                    trade.sl = min(trade.sl, self.data.High[-1])
+
+    def smc_buy(self, data, swing_hl):
+        return SMC(data, swing_hl).backtest_buy_signal_structure()
+
+    def smc_sell(self, data, swing_hl):
+        return SMC(data, swing_hl).backtest_sell_signal_structure()
+
+    def nearest_swing(self, data, swing_hl):
+        # Get swing high/low nearest to current price.
+        swings = SMC(data, swing_hl).swing_hl
+        swings = swings[~np.isnan(swings['Level'])]
+        return swings['Level'].iloc[-2]
+
+strategies = {'Order Block': SMC_test, 'Order Block with EMA': SMC_ema , 'Structure trading': SMCStructure}
+
+if __name__ == "__main__":
+    from utils import fetch
+    # data = fetch('ICICIBANK.NS', period='1mo', interval='15m')
+    data = fetch('RELIANCE.NS', period='1mo', interval='15m')
+    # data = fetch('AXISBANK.NS', period='1mo', interval='15m')
+    # bt = Backtest(data, SMC_ema, commission=.002)
+    # bt.run(ema1 = 9, ema2 = 21, close_on_crossover=True)
+    bt = Backtest(data, SMCStructure, commission = .002, trade_on_close=True)
+    print(bt.run())
+
+    # bt.plot()

streamlit_app.py

@@ -0,0 +1,11 @@
+import streamlit as st
+
+st.set_page_config(page_title="Algorithmic Trading Dashboard", layout="wide", initial_sidebar_state="auto",
+                       menu_items=None, page_icon=":chart_with_upwards_trend:")
+
+dashboard = st.Page("pages/dashboard.py", title="Dashboard")
+complete_test = st.Page("pages/complete_backtest.py", title="Nifty50 Test")
+
+pg = st.navigation([dashboard, complete_test])
+
+pg.run()

utils.py

@@ -0,0 +1,147 @@
+import yfinance as yf
+from backtesting import Backtest
+import pandas as pd
+import random
+
+from strategies import SMC_test, SMC_ema, SMCStructure
+
+def fetch(symbol, period, interval):
+    df = yf.download(symbol, period=period, interval=interval)
+    df.columns =df.columns.get_level_values(0)
+    return df
+
+def smc_plot_backtest(data, filename, swing_hl, **kwargs):
+    bt = Backtest(data, SMC_test, **kwargs)
+    bt.run(swing_window=swing_hl)
+    return bt.plot(filename=filename, open_browser=False)
+
+def smc_ema_plot_backtest(data, filename, ema1, ema2, closecross, **kwargs):
+    bt = Backtest(data, SMC_ema, **kwargs)
+    bt.run(ema1=ema1, ema2=ema2, close_on_crossover=closecross)
+    return bt.plot(filename=filename, open_browser=False)
+
+def smc_structure_plot_backtest(data, filename, swing_hl, **kwargs):
+    bt = Backtest(data, SMCStructure, **kwargs)
+    bt.run(swing_window=swing_hl)
+    return bt.plot(filename=filename, open_browser=False)
+
+def smc_backtest(data, swing_hl, **kwargs):
+    bt = Backtest(data, SMC_test, **kwargs)
+    results = bt.run(swing_window=swing_hl)
+    bt.plot(filename='bokeh_graph.html', open_browser=False)
+    return results
+
+def smc_ema_backtest(data, ema1, ema2, closecross, **kwargs):
+    bt = Backtest(data, SMC_ema, **kwargs)
+    results = bt.run(ema1=ema1, ema2=ema2, close_on_crossover=closecross)
+    bt.plot(filename='bokeh_graph.html', open_browser=False)
+    return results
+
+def smc_structure_backtest(data, swing_hl, **kwargs):
+    bt = Backtest(data, SMCStructure, **kwargs)
+    results = bt.run(swing_window=swing_hl)
+    bt.plot(filename='bokeh_graph.html', open_browser=False)
+    return results
+
+def random_test(strategy: str, period: str, interval: str, no_of_stocks: int = 5, **kwargs):
+    nifty50 = pd.read_csv("data/ind_nifty50list.csv")
+    ticker_list = pd.read_csv("data/Ticker_List_NSE_India.csv")
+
+    # Merging nifty50 and ticker_list dataframes to get 'YahooEquiv' column.
+    nifty50 = nifty50.merge(ticker_list, "inner", left_on=['Symbol'], right_on=['SYMBOL'])
+
+    # Generating random indices between 0 and len(nifty50).
+    random_indices = random.sample(range(0, len(nifty50)), no_of_stocks)
+
+    df = pd.DataFrame()
+
+    for i in random_indices:
+        # Fetching ohlc of random ticker_symbol.
+        ticker_symbol = nifty50['YahooEquiv'].values[i]
+        data = fetch(ticker_symbol, period, interval)
+
+        if strategy == "Order Block":
+            backtest_results = smc_backtest(data, kwargs['swing_hl'])
+        elif strategy == "Order Block with EMA":
+            backtest_results = smc_ema_backtest(data, kwargs['ema1'], kwargs['ema2'], kwargs['cross_close'])
+        elif strategy == "Structure trading":
+            backtest_results = smc_structure_backtest(data, kwargs['swing_hl'])
+        else:
+            raise Exception('Strategy not found')
+
+        with open("bokeh_graph.html", 'r', encoding='utf-8') as f:
+            plot = f.read()
+
+        # Converting pd.Series to pd.Dataframe
+        backtest_results = backtest_results.to_frame().transpose()
+
+        backtest_results['stock'] = ticker_symbol
+
+        # Reordering columns.
+        # cols = df.columns.tolist()
+        # cols = cols[-1:] + cols[:-1]
+        cols = ['stock', 'Start', 'End', 'Return [%]', 'Equity Final [$]', 'Buy & Hold Return [%]', '# Trades', 'Win Rate [%]', 'Best Trade [%]', 'Worst Trade [%]', 'Avg. Trade [%]']
+        backtest_results = backtest_results[cols]
+
+        df = pd.concat([df, backtest_results])
+
+    df = df.sort_values(by=['Return [%]'], ascending=False)
+
+    return df
+
+def complete_test(strategy: str, period: str, interval: str, **kwargs):
+    nifty50 = pd.read_csv("data/ind_nifty50list.csv")
+    ticker_list = pd.read_csv("data/Ticker_List_NSE_India.csv")
+
+    # Merging nifty50 and ticker_list dataframes to get 'YahooEquiv' column.
+    nifty50 = nifty50.merge(ticker_list, "inner", left_on=['Symbol'], right_on=['SYMBOL'])
+
+    df = pd.DataFrame()
+
+    for i in range(len(nifty50)):
+    # for i in range(5):
+
+        # Fetching ohlc of random ticker_symbol.
+        ticker_symbol = nifty50['YahooEquiv'].values[i]
+        data = fetch(ticker_symbol, period, interval)
+
+        if strategy == "Order Block":
+            backtest_results = smc_backtest(data, kwargs['swing_hl'])
+        elif strategy == "Order Block with EMA":
+            backtest_results = smc_ema_backtest(data, kwargs['ema1'], kwargs['ema2'], kwargs['cross_close'])
+        elif strategy == "Structure trading":
+            backtest_results = smc_structure_backtest(data, kwargs['swing_hl'])
+        else:
+            raise Exception('Strategy not found')
+
+        with open("bokeh_graph.html", 'r', encoding='utf-8') as f:
+            plot = f.read()
+
+        # Converting pd.Series to pd.Dataframe
+        backtest_results = backtest_results.to_frame().transpose()
+
+        backtest_results['stock'] = ticker_symbol
+        backtest_results['plot'] = plot
+
+        # Reordering columns.
+        # cols = df.columns.tolist()
+        # cols = cols[-1:] + cols[:-1]
+        cols = ['stock', 'Start', 'End', 'Return [%]', 'Equity Final [$]', 'Buy & Hold Return [%]', '# Trades', 'Win Rate [%]', 'Best Trade [%]', 'Worst Trade [%]', 'Avg. Trade [%]', 'plot']
+        backtest_results = backtest_results[cols]
+
+        df = pd.concat([df, backtest_results])
+
+    df['plot'] = df['plot'].astype(str)
+    df = df.sort_values(by=['Return [%]'], ascending=False)
+
+    return df
+
+
+if __name__ == "__main__":
+    # random_testing("")
+    # data = fetch('RELIANCE.NS', period='1y', interval='15m')
+    # df = yf.download('RELIANCE.NS', period='1yr', interval='15m')
+
+    rt = complete_test("Order Block", '1mo', '15m', swing_hl=20)
+    rt.to_excel('test/all_testing_1.xlsx', index=False)
+    print(rt)