Stoch+StochRSI-Bot-Back-Testing.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Fiverr Bot Back-Testing.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "i0GOGZKVjFjZ"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/tejaslinge/Technical-Analysis-using-Python/blob/main/Stoch%2BStochRSI-Bot-Back-Testing.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_6jASB7Ti_LC"
      },
      "outputs": [],
      "source": [
        "!pip install alpaca-trade-api"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Dependencies"
      ],
      "metadata": {
        "id": "i0GOGZKVjFjZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#### config_params.py\n",
        "\n",
        "import json\n",
        "config = json.loads(open('ConfigFile.txt', 'r').read()) # Config File with All Parameters\n",
        "# setting up parameters\n",
        "# Order Params\n",
        "global max_trades\n",
        "global trade_capital_percent\n",
        "global stop_loss\n",
        "global trailing_stop\n",
        "investment_amount = config[\"investment_amount\"]\n",
        "max_trades = config[\"max_trades_active\"]\n",
        "trade_capital_percent = config[\"trade_capital_percent\"]\n",
        "stop_loss = config[\"stop_loss\"]\n",
        "trailing_stop = config[\"trailing_stop\"]\n",
        "limit_price = config[\"limit_price\"]\n",
        "lookback_period = config[\"candle_lookback_period\"]\n",
        "activate_trailing_stop_loss_at = config[\"activate_trailing_stop_loss_at\"]\n",
        "\n",
        "# Data Collection Params\n",
        "global start_date\n",
        "global end_date\n",
        "global timeframe\n",
        "start_date = config[\"start_date\"]\n",
        "start_date = int(start_date.split()[0])\n",
        "# start_date = int(start_date)\n",
        "\n",
        "end_date = config[\"end_date\"]\n",
        "timeframe = config[\"timeframe\"]\n",
        "exchange = config[\"exchange\"]\n",
        "\n",
        "# Technical Indicator (TI) Params\n",
        "ema = config['indicators']['EMA']\n",
        "stoch_rsi = config['indicators']['stochRSI']\n",
        "stoch = config['indicators']['stoch']\n",
        "ema_params = config['indicators']['EMA_params'] # EMA_Params: Period, Source (Close)\n",
        "stoch_params = config['indicators']['stoch_params'] # Stoch_Params: K_Length, Lower Band, smooth_D, smooth_K\n",
        "stochRSI_params = config['indicators']['stochRSI_params'] # StochRSI_Params: K, D, Lower Band, RSI Length, Source (Close)\n",
        "\n",
        "# ema_period = ema_params['period']\n",
        "ema_smoothing = ema_params['smoothing']\n",
        "# ema_fast = ema_params['fast_period']\n",
        "ema_slow = ema_params['slow_period']\n",
        "\n",
        "stoch_upper_band = stoch_params['upper_band']\n",
        "stoch_lower_band= stoch_params['lower_band']\n",
        "stoch_klength = stoch_params['K_Length']\n",
        "stoch_smoothk = stoch_params['smooth_K']\n",
        "stoch_smoothd = stoch_params['smooth_D']\n",
        "\n",
        "stochRSI_length = stochRSI_params['rsi_length']\n",
        "stochRSI_rsi_length = stochRSI_params['rsi_length']\n",
        "stochRSI_upper_band = stochRSI_params['upper_band']\n",
        "stochRSI_lower_band = stochRSI_params['lower_band']\n",
        "stochRSI_k = stochRSI_params['K']\n",
        "stochRSI_d = stochRSI_params['D']"
      ],
      "metadata": {
        "id": "sOAPUVcpjC9C"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "### Signals \n",
        "import numpy as np\n",
        "def implement_stoch_strategy(ticker, upper_band = stoch_upper_band, lower_band = stoch_lower_band):    \n",
        "    buy_price = []\n",
        "    sell_price = []\n",
        "    stoch_signal = []\n",
        "    signal = 0\n",
        "\n",
        "    prices = ticker['Close']\n",
        "    k = ticker['Stoch %K']\n",
        "    d = ticker['Stoch %D']\n",
        "\n",
        "    for i in range(len(prices)):\n",
        "        if k[i] < lower_band and d[i] < lower_band and k[i] < d[i]:\n",
        "            if signal != 1:\n",
        "                buy_price.append(prices[i])\n",
        "                sell_price.append(np.nan)\n",
        "                signal = 1\n",
        "                stoch_signal.append(signal)\n",
        "            else:\n",
        "                buy_price.append(np.nan)\n",
        "                sell_price.append(np.nan)\n",
        "                stoch_signal.append(0)\n",
        "        elif k[i] > upper_band and d[i] > upper_band and k[i] > d[i]:\n",
        "            if signal != -1:\n",
        "                buy_price.append(np.nan)\n",
        "                sell_price.append(prices[i])\n",
        "                signal = -1\n",
        "                stoch_signal.append(signal)\n",
        "            else:\n",
        "                buy_price.append(np.nan)\n",
        "                sell_price.append(np.nan)\n",
        "                stoch_signal.append(0)\n",
        "        else:\n",
        "            buy_price.append(np.nan)\n",
        "            sell_price.append(np.nan)\n",
        "            stoch_signal.append(0)\n",
        "\n",
        "    ticker['Stoch Signal'] = stoch_signal\n",
        "#     print(stoch_signal)\n",
        "    return ticker\n",
        "\n",
        "def implement_ema_strategy(prices, period = ema_slow):\n",
        "    cols = list(prices.columns)\n",
        "    ema = prices['Close'].ewm(span = period, adjust = False).mean()\n",
        "    prices[\"EMA\"] = ema\n",
        "    prices['Signal_EMA'] = np.where(prices['EMA'] > prices['Close'], 1.0, 0.0)\n",
        "    prices['EMA Signal'] = prices['Signal_EMA'].diff()    \n",
        "    cols += [\"EMA Signal\"]\n",
        "    prices = prices[cols]\n",
        "    return prices\n",
        "\n",
        "def implement_stochRSI_strategy(ticker, upper_band = stochRSI_upper_band, lower_band = stochRSI_lower_band):\n",
        "    buy_price = []\n",
        "    sell_price = []\n",
        "    stoch_signal = []\n",
        "    signal = 0\n",
        "\n",
        "    prices = ticker['Close']\n",
        "    k = ticker['StochRSI_K']\n",
        "    d = ticker['StochRSI_D']\n",
        "\n",
        "    for i in range(len(prices)):\n",
        "        if k[i] < lower_band and d[i] < lower_band and k[i] < d[i]:\n",
        "            if signal != 1:\n",
        "                buy_price.append(prices[i])\n",
        "                sell_price.append(np.nan)\n",
        "                signal = 1\n",
        "                stoch_signal.append(signal)\n",
        "            else:\n",
        "                buy_price.append(np.nan)\n",
        "                sell_price.append(np.nan)\n",
        "                stoch_signal.append(0)\n",
        "        elif k[i] > upper_band and d[i] > upper_band and k[i] > d[i]:\n",
        "            if signal != -1:\n",
        "                buy_price.append(np.nan)\n",
        "                sell_price.append(prices[i])\n",
        "                signal = -1\n",
        "                stoch_signal.append(signal)\n",
        "            else:\n",
        "                buy_price.append(np.nan)\n",
        "                sell_price.append(np.nan)\n",
        "                stoch_signal.append(0)\n",
        "        else:\n",
        "            buy_price.append(np.nan)\n",
        "            sell_price.append(np.nan)\n",
        "            stoch_signal.append(0)\n",
        "\n",
        "    ticker['Stoch RSI Signal'] = stoch_signal\n",
        "    return ticker"
      ],
      "metadata": {
        "id": "e_b2kk9Hjlxt"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#### indicator.py\n",
        "############################################################\n",
        "#TECHNICAL INDICATORS\n",
        "\n",
        "# calculating Stoch RSI (gives the same values as TradingView)\n",
        "# https://www.tradingview.com/wiki/Stochastic_RSI_(STOCH_RSI) \n",
        "def stochRSI(data, k_window = stochRSI_k, d_window = stochRSI_d, window = stochRSI_length, rsi_window = stochRSI_rsi_length):\n",
        "        \n",
        "    def computeRSI (data, rsi_window = rsi_window):\n",
        "        diff = data.diff(1).dropna()        # diff in one field(one day)\n",
        "        #this preservers dimensions off diff values\n",
        "        up_chg = 0 * diff\n",
        "        down_chg = 0 * diff\n",
        "        # up change is equal to the positive difference, otherwise equal to zero\n",
        "        up_chg[diff > 0] = diff[ diff>0 ]\n",
        "        # down change is equal to negative deifference, otherwise equal to zero\n",
        "        down_chg[diff < 0] = diff[ diff < 0 ]\n",
        "        # check pandas documentation for ewm\n",
        "        # https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.ewm.html\n",
        "        # values are related to exponential decay\n",
        "        # we set com=time_window-1 so we get decay alpha=1/time_window\n",
        "        up_chg_avg   = up_chg.ewm(com=rsi_window-1 , min_periods=rsi_window).mean()\n",
        "        down_chg_avg = down_chg.ewm(com=rsi_window-1 , min_periods=rsi_window).mean()\n",
        "        rs = abs(up_chg_avg/down_chg_avg)\n",
        "        rsi = 100 - 100/(1+rs)\n",
        "        return rsi\n",
        "    \n",
        "    data_temp = data['Close']\n",
        "    data_temp = computeRSI(data_temp, rsi_window)\n",
        "    \n",
        "    # input to function is one column from df\n",
        "    # containing closing price or whatever value we want to extract K and D from\n",
        "    min_val  = data_temp.rolling(window=window, center=False).min()\n",
        "    max_val = data_temp.rolling(window=window, center=False).max()\n",
        "    stoch = ( (data_temp - min_val) / (max_val - min_val) ) * 100\n",
        "    K = stoch.rolling(window=k_window, center=False).mean() \n",
        "    #K = stoch\n",
        "    D = K.rolling(window=d_window, center=False).mean() \n",
        "    \n",
        "    data['StochRSI_K'] = K\n",
        "    data['StochRSI_D'] = D    \n",
        "    return data\n",
        "\n",
        "def stochastic(ticker, period = stoch_klength, smoothK = stoch_smoothk, smoothD = stoch_smoothd): ## verified\n",
        "    cols = list(ticker.columns)[1:]\n",
        "    ticker['14-high'] = ticker['High'].rolling(period).max()\n",
        "    ticker['14-low'] = ticker['Low'].rolling(period).min()\n",
        "    ticker['Stoch %K'] = ((ticker['Close'] - ticker['14-low'])*100/(ticker['14-high'] - ticker['14-low'])).rolling(smoothK).mean()\n",
        "    ticker['Stoch %D'] = ticker['Stoch %K'].rolling(smoothD).mean()\n",
        "    ticker.drop(columns = ['14-low', '14-high'], inplace = True)\n",
        "    return ticker\n",
        "\n",
        "def RSI(series, period=14): # ✔︎✔︎ RSI_EWM\n",
        "    delta = series.diff().dropna()\n",
        "    ups = delta * 0\n",
        "    downs = ups.copy()\n",
        "    ups[delta > 0] = delta[delta > 0]\n",
        "    downs[delta < 0] = -delta[delta < 0]\n",
        "    ups[ups.index[period-1]] = np.mean( ups[:period] ) #first value is sum of avg gains\n",
        "    ups = ups.drop(ups.index[:(period-1)])\n",
        "    downs[downs.index[period-1]] = np.mean( downs[:period] ) #first value is sum of avg losses\n",
        "    downs = downs.drop(downs.index[:(period-1)])\n",
        "    rs = ups.ewm(com=period-1,min_periods=0,adjust=False,ignore_na=False).mean() / \\\n",
        "         downs.ewm(com=period-1,min_periods=0,adjust=False,ignore_na=False).mean() \n",
        "    return 100 - 100 / (1 + rs)\n",
        "\n",
        "# calculating Stoch RSI \n",
        "#  -- Same as the above function but uses EMA, not SMA\n",
        "def StochRSI_EMA(series, period=14, smoothK=3, smoothD=3):\n",
        "    # Calculate RSI \n",
        "    delta = series.diff().dropna()\n",
        "    ups = delta * 0\n",
        "    downs = ups.copy()\n",
        "    ups[delta > 0] = delta[delta > 0]\n",
        "    downs[delta < 0] = -delta[delta < 0]\n",
        "    ups[ups.index[period-1]] = np.mean( ups[:period] ) #first value is sum of avg gains\n",
        "    ups = ups.drop(ups.index[:(period-1)])\n",
        "    downs[downs.index[period-1]] = np.mean( downs[:period] ) #first value is sum of avg losses\n",
        "    downs = downs.drop(downs.index[:(period-1)])\n",
        "    rs = ups.ewm(com=period-1,min_periods=0,adjust=False,ignore_na=False).mean() / \\\n",
        "         downs.ewm(com=period-1,min_periods=0,adjust=False,ignore_na=False).mean() \n",
        "    rsi = 100 - 100 / (1 + rs)\n",
        "\n",
        "    # Calculate StochRSI \n",
        "    stochrsi  = (rsi - rsi.rolling(period).min()) / (rsi.rolling(period).max() - rsi.rolling(period).min())\n",
        "    stochrsi_K = stochrsi.ewm(span=smoothK).mean()\n",
        "    stochrsi_D = stochrsi_K.ewm(span=smoothD).mean()\n",
        "\n",
        "    return stochrsi, stochrsi_K, stochrsi_D\n",
        "\n",
        "# stochRSI(ticker, period=14, smoothK=3, smoothD=3) VERIFIED\n",
        "# stochastic(ticker, period = 14, smoothK = 3, smoothD = 3) VERIFIED\n",
        "# StochRSI_EMA(series, period=14, smoothK=3, smoothD=3) VERIFIED\n",
        "# RSI(series, period=14) VERIFIED\n",
        "# EMA (ticker, period = 5, smoothing = 2)\n",
        "\n",
        "############################################################"
      ],
      "metadata": {
        "id": "vpJf7TWojr6g"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import requests\n",
        "import json\n",
        "from datetime import datetime as dt\n",
        "from datetime import timedelta\n",
        "from math import floor\n",
        "\n",
        "import alpaca_trade_api as alpaca\n",
        "\n",
        "# Files\n",
        "# auth = json.loads(open('AUTH/auth.txt', 'r').read()) # API-KEY and API-SECRET\n",
        "# client = Client(auth[\"API-KEY\"], auth[\"API-SECRET\"])\n",
        "key = json.loads(open('authAlpaca.txt', 'r').read())\n",
        "api = alpaca.REST(key['APCA-API-KEY-ID'], key['APCA-API-SECRET-KEY'], base_url=key[\"BASE-URL\"], api_version = 'v2')\n",
        "tickers = open('Tickers.txt', 'r').read() # Tickers\n",
        "tickers = tickers.split()\n",
        "\n",
        "# Function to fetch data\n",
        "def get_data(ticker, timeframe= timeframe, start_date = int(start_date), exchanges = exchange):\n",
        "    df = api.get_crypto_bars(ticker, timeframe, (dt.now() - timedelta(days = start_date)).strftime(\"%Y-%m-%d\"), dt.now().strftime(\"%Y-%m-%d\"), exchanges = exchange).df\n",
        "#     df.drop(columns = 'exchange', inplace = True)\n",
        "    df.reset_index(inplace = True)\n",
        "#     df = df.loc[:, : 'close']\n",
        "\n",
        "    df = df[['timestamp', 'open', 'high', 'low', 'close']]\n",
        "    df.columns = ['Timestamp', 'Open', 'High', 'Low', 'Close']\n",
        "    # print(df.columns)\n",
        "    return df\n",
        "\n",
        "def stochBacktest(ticker):\n",
        "    df = get_data(ticker)\n",
        "    df = stochastic(df)\n",
        "    # buy_price, sell_price, stoch_signal = implement_stoch_strategy(df['Close'], df['Stoch %K'], df['Stoch %D'])\n",
        "    df = implement_stoch_strategy(df)\n",
        "    stoch_signal = df['Stoch Signal']\n",
        "    df['nextDayClose'] = df['Close'].shift(-1)\n",
        "    buyDates = []\n",
        "\n",
        "    for i in range(len(stoch_signal)):\n",
        "        if stoch_signal[i]==1.0:\n",
        "            buyDates.append(df['Timestamp'][i])\n",
        "            \n",
        "    buyDate = None\n",
        "    buyDateClose = None\n",
        "    investment_value = investment_amount\n",
        "    finalInvestmentValue = investment_amount\n",
        "    number_of_stocks = None\n",
        "    newStockValueForTrailing = None\n",
        "    trailing_stop_loss_at = activate_trailing_stop_loss_at\n",
        "    changeInInvestmentValue = None\n",
        "#         buys = []\n",
        "    sells = []\n",
        "    soldAtLast = True\n",
        "\n",
        "    for i in range(0,df.shape[0]):\n",
        "        if buyDates.count(df['Timestamp'][i]) == 1 and buyDate==None and buyDateClose==None:\n",
        "            buyDate = df['Timestamp'][i]\n",
        "            buyDateClose = df['Close'][i]\n",
        "            number_of_stocks = floor(finalInvestmentValue/buyDateClose)\n",
        "            finalInvestmentValue -= number_of_stocks*buyDateClose\n",
        "#                 buys.append(finalInvestmentValue)\n",
        "            newStockValueForTrailing = buyDateClose*((100+trailing_stop_loss_at)/100)\n",
        "            soldAtLast = False\n",
        "#                 print(i, \"stocks bought\", number_of_stocks, \"cost\", number_of_stocks*buyDateClose, \"total\", finalInvestmentValue)\n",
        "\n",
        "        if buyDate!=None and buyDateClose!=None:\n",
        "            if df['Close'][i]<=((100-stop_loss)/100)*buyDateClose or df['Close'][i]>=((100+limit_price)/100)*buyDateClose:\n",
        "                ##direct sell\n",
        "                finalInvestmentValue += number_of_stocks*df['Close'][i]\n",
        "                sells.append(finalInvestmentValue)\n",
        "#                     print(i, \"direct stocks sold\", number_of_stocks, \"cost\", number_of_stocks*df['Close'][i], \"total\", finalInvestmentValue)\n",
        "                buyDate=None\n",
        "                buyDateClose=None\n",
        "                soldAtLast = True\n",
        "            elif df['Close'][i]>=newStockValueForTrailing:\n",
        "                minStockValueForTrailing = df['Close'][i]*((100-trailing_stop)/100)\n",
        "                maxStockValueForTrailing = df['Close'][i]*((100+limit_price)/100)\n",
        "                if df['nextDayClose'][i]>=maxStockValueForTrailing or df['nextDayClose'][i]<minStockValueForTrailing:\n",
        "    #                 number_of_stocks = floor(finalInvestmentValue/df['Close'][i])\n",
        "                    finalInvestmentValue += number_of_stocks*df['Close'][i]\n",
        "                    sells.append(finalInvestmentValue)\n",
        "#                         print(i, \"stocks sold\", number_of_stocks, \"cost\", number_of_stocks*df['Close'][i], \"total\", finalInvestmentValue)\n",
        "                    buyDate=None\n",
        "                    buyDateClose=None\n",
        "                    soldAtLast = True\n",
        "\n",
        "#    \n",
        "    if len(buyDates) != 0:\n",
        "      startDate = buyDates[1].strftime(\"%Y-%m-%d %H:%M:%s\")\n",
        "      endDate = buyDates[-1].strftime(\"%Y-%m-%d %H:%M:%s\")\n",
        "    else:\n",
        "      startDate = None\n",
        "      endDate = None\n",
        "    print('Timeframe: {}, \\nStart Date: {}, \\nEnd Date: {}, \\nStop Loss: {}, \\nTrailing Stop Loss activates at: {}, \\nTrailing Stop Loss: {}'.format(timeframe, startDate, endDate, stop_loss, activate_trailing_stop_loss_at, trailing_stop))\n",
        "    if soldAtLast:\n",
        "        changeInInvestmentValue =  ((finalInvestmentValue - investment_value)/investment_value)*100\n",
        "        print('Total Investment Remaining: {}'.format(finalInvestmentValue))\n",
        "        print('Profit gained from the strategy by investing $100k in {} : {}'.format(ticker, finalInvestmentValue-investment_value))\n",
        "        print('Profit percentage of the strategy : {}%'.format(changeInInvestmentValue))\n",
        "    else:\n",
        "        changeInInvestmentValue =  ((sells[-1] - investment_value)/investment_value)*100\n",
        "        print('Total Investment Remaining: {}'.format(sells[-1]))\n",
        "        print('Profit gained from the strategy by investing $100k in {} : {}'.format(ticker, sells[-1]-investment_value))\n",
        "        print('Profit percentage of the strategy : {}%'.format(changeInInvestmentValue))\n",
        "\n",
        "def EMAbacktest(ticker):\n",
        "    df = get_data(ticker)\n",
        "    df = implement_ema_strategy(df)\n",
        "    df['nextDayClose'] = df['Close'].shift(-1)\n",
        "    ema_signal = df['EMA Signal']\n",
        "    buyDates = []\n",
        "\n",
        "    for i in range(len(ema_signal)):\n",
        "        if ema_signal[i]==1.0:\n",
        "            buyDates.append(df['Timestamp'][i])\n",
        "            \n",
        "    buyDate = None\n",
        "    buyDateClose = None\n",
        "    investment_value = investment_amount\n",
        "    finalInvestmentValue = investment_amount\n",
        "    number_of_stocks = None\n",
        "    newStockValueForTrailing = None\n",
        "    trailing_stop_loss_at = activate_trailing_stop_loss_at\n",
        "    changeInInvestmentValue = None\n",
        "#         buys = []\n",
        "    sells = []\n",
        "    soldAtLast = True\n",
        "\n",
        "    for i in range(0,df.shape[0]):\n",
        "        if buyDates.count(df['Timestamp'][i]) == 1 and buyDate==None and buyDateClose==None:\n",
        "            buyDate = df['Timestamp'][i]\n",
        "            buyDateClose = df['Close'][i]\n",
        "            number_of_stocks = floor(finalInvestmentValue/buyDateClose)\n",
        "            finalInvestmentValue -= number_of_stocks*buyDateClose\n",
        "#                 buys.append(finalInvestmentValue)\n",
        "            newStockValueForTrailing = buyDateClose*((100+trailing_stop_loss_at)/100)\n",
        "            soldAtLast = False\n",
        "#                 print(i, \"stocks bought\", number_of_stocks, \"cost\", number_of_stocks*buyDateClose, \"total\", finalInvestmentValue)\n",
        "\n",
        "        if buyDate!=None and buyDateClose!=None:\n",
        "            if df['Close'][i]<=((100-stop_loss)/100)*buyDateClose or df['Close'][i]>=((100+limit_price)/100)*buyDateClose:\n",
        "                ##direct sell\n",
        "                finalInvestmentValue += number_of_stocks*df['Close'][i]\n",
        "                sells.append(finalInvestmentValue)\n",
        "#                     print(i, \"direct stocks sold\", number_of_stocks, \"cost\", number_of_stocks*df['Close'][i], \"total\", finalInvestmentValue)\n",
        "                buyDate=None\n",
        "                buyDateClose=None\n",
        "                soldAtLast = True\n",
        "            elif df['Close'][i]>=newStockValueForTrailing:\n",
        "                minStockValueForTrailing = df['Close'][i]*((100-trailing_stop)/100)\n",
        "                maxStockValueForTrailing = df['Close'][i]*((100+limit_price)/100)\n",
        "                if df['nextDayClose'][i]>=maxStockValueForTrailing or df['nextDayClose'][i]<minStockValueForTrailing:\n",
        "    #                 number_of_stocks = floor(finalInvestmentValue/df['Close'][i])\n",
        "                    finalInvestmentValue += number_of_stocks*df['Close'][i]\n",
        "                    sells.append(finalInvestmentValue)\n",
        "#                         print(i, \"stocks sold\", number_of_stocks, \"cost\", number_of_stocks*df['Close'][i], \"total\", finalInvestmentValue)\n",
        "                    buyDate=None\n",
        "                    buyDateClose=None\n",
        "                    soldAtLast = True\n",
        "\n",
        "#         print(soldAtLast, sells)\n",
        "    if len(buyDates) != 0:\n",
        "      startDate = buyDates[1].strftime(\"%Y-%m-%d %H:%M:%s\")\n",
        "      endDate = buyDates[-1].strftime(\"%Y-%m-%d %H:%M:%s\")\n",
        "    else:\n",
        "      startDate = None\n",
        "      endDate = None\n",
        "    print('Timeframe: {}, \\nStart Date: {}, \\nEnd Date: {}, \\nStop Loss: {}, \\nTrailing Stop Loss activates at: {}, \\nTrailing Stop Loss: {}'.format(timeframe, startDate, endDate, stop_loss, activate_trailing_stop_loss_at, trailing_stop))\n",
        "    if soldAtLast:\n",
        "        changeInInvestmentValue =  ((finalInvestmentValue - investment_value)/investment_value)*100\n",
        "        print('Total Investment Remaining: {}'.format(finalInvestmentValue))\n",
        "        print('Profit gained from the strategy by investing $100k in {} : {}'.format(ticker, finalInvestmentValue-investment_value))\n",
        "        print('Profit percentage of the strategy : {}%'.format(changeInInvestmentValue))\n",
        "    else:\n",
        "        changeInInvestmentValue =  ((sells[-1] - investment_value)/investment_value)*100\n",
        "        print('Total Investment Remaining: {}'.format(sells[-1]))\n",
        "        print('Profit gained from the strategy by investing $100k in {} : {}'.format(ticker, sells[-1]-investment_value))\n",
        "        print('Profit percentage of the strategy : {}%'.format(changeInInvestmentValue))\n",
        "    \n",
        "def stochRSIBacktest(ticker):\n",
        "    df = get_data(ticker)\n",
        "    df = stochRSI(df)\n",
        "    df = implement_stochRSI_strategy(df)\n",
        "    stochRSI_signal = df['Stoch RSI Signal']\n",
        "    df['nextDayClose'] = df['Close'].shift(-1)\n",
        "    buyDates = []\n",
        "\n",
        "    for i in range(len(stochRSI_signal)):\n",
        "        if stochRSI_signal[i]==1.0:\n",
        "            buyDates.append(df['Timestamp'][i])\n",
        "            \n",
        "    buyDate = None\n",
        "    buyDateClose = None\n",
        "    investment_value = investment_amount\n",
        "    finalInvestmentValue = investment_amount\n",
        "    number_of_stocks = None\n",
        "    newStockValueForTrailing = None\n",
        "    trailing_stop_loss_at = activate_trailing_stop_loss_at\n",
        "    changeInInvestmentValue = None\n",
        "#         buys = []\n",
        "    sells = []\n",
        "    soldAtLast = True\n",
        "\n",
        "    for i in range(0,df.shape[0]):\n",
        "        if buyDates.count(df['Timestamp'][i]) == 1 and buyDate==None and buyDateClose==None:\n",
        "            buyDate = df['Timestamp'][i]\n",
        "            buyDateClose = df['Close'][i]\n",
        "            number_of_stocks = floor(finalInvestmentValue/buyDateClose)\n",
        "            finalInvestmentValue -= number_of_stocks*buyDateClose\n",
        "#                 buys.append(finalInvestmentValue)\n",
        "            newStockValueForTrailing = buyDateClose*((100+trailing_stop_loss_at)/100)\n",
        "            soldAtLast = False\n",
        "#                 print(i, \"stocks bought\", number_of_stocks, \"cost\", number_of_stocks*buyDateClose, \"total\", finalInvestmentValue)\n",
        "\n",
        "        if buyDate!=None and buyDateClose!=None:\n",
        "            if df['Close'][i]<=((100-stop_loss)/100)*buyDateClose or df['Close'][i]>=((100+limit_price)/100)*buyDateClose:\n",
        "                ##direct sell\n",
        "                finalInvestmentValue += number_of_stocks*df['Close'][i]\n",
        "                sells.append(finalInvestmentValue)\n",
        "#                     print(i, \"direct stocks sold\", number_of_stocks, \"cost\", number_of_stocks*df['Close'][i], \"total\", finalInvestmentValue)\n",
        "                buyDate=None\n",
        "                buyDateClose=None\n",
        "                soldAtLast = True\n",
        "            elif df['Close'][i]>=newStockValueForTrailing:\n",
        "                minStockValueForTrailing = df['Close'][i]*((100-trailing_stop)/100)\n",
        "                maxStockValueForTrailing = df['Close'][i]*((100+limit_price)/100)\n",
        "                if df['nextDayClose'][i]>=maxStockValueForTrailing or df['nextDayClose'][i]<minStockValueForTrailing:\n",
        "    #                 number_of_stocks = floor(finalInvestmentValue/df['Close'][i])\n",
        "                    finalInvestmentValue += number_of_stocks*df['Close'][i]\n",
        "                    sells.append(finalInvestmentValue)\n",
        "#                         print(i, \"stocks sold\", number_of_stocks, \"cost\", number_of_stocks*df['Close'][i], \"total\", finalInvestmentValue)\n",
        "                    buyDate=None\n",
        "                    buyDateClose=None\n",
        "                    soldAtLast = True\n",
        "\n",
        "#         print(soldAtLast, sells)\n",
        "    \n",
        "    if len(buyDates) != 0:\n",
        "      startDate = buyDates[1].strftime(\"%Y-%m-%d %H:%M:%s\")\n",
        "      endDate = buyDates[-1].strftime(\"%Y-%m-%d %H:%M:%s\")\n",
        "    else:\n",
        "      startDate = None\n",
        "      endDate = None\n",
        "    print('Timeframe: {}, \\nStart Date: {}, \\nEnd Date: {}, \\nStop Loss: {}, \\nTrailing Stop Loss activates at: {}, \\nTrailing Stop Loss: {}'.format(timeframe, startDate, endDate, stop_loss, activate_trailing_stop_loss_at, trailing_stop))\n",
        "    if soldAtLast:\n",
        "        changeInInvestmentValue =  ((finalInvestmentValue - investment_value)/investment_value)*100\n",
        "        print('Total Investment Remaining: {}'.format(finalInvestmentValue))\n",
        "        print('Profit gained from the strategy by investing $100k in {} : {}'.format(ticker, finalInvestmentValue-investment_value))\n",
        "        print('Profit percentage of the strategy : {}%'.format(changeInInvestmentValue))\n",
        "    else:\n",
        "        changeInInvestmentValue =  ((sells[-1] - investment_value)/investment_value)*100\n",
        "        print('Total Investment Remaining: {}'.format(sells[-1]))\n",
        "        print('Profit gained from the strategy by investing $100k in {} : {}'.format(ticker, sells[-1]-investment_value))\n",
        "        print('Profit percentage of the strategy : {}%'.format(changeInInvestmentValue))\n",
        "\n",
        "def stoch_StochRSI_EMA_Backtest(ticker, stoch=False, stoch_RSI=False, ema=False, lookback_period=1):\n",
        "    if stoch == False and stoch_RSI == False and ema == False:\n",
        "        print(\"Atleast one parameter should be TRUE.\")\n",
        "    elif stoch == True and stoch_RSI == False and ema == False:\n",
        "        stochBacktest(ticker)\n",
        "    elif stoch == False and stoch_RSI == True and ema == False:\n",
        "        stochRSIBacktest(ticker)\n",
        "    elif stoch == False and stoch_RSI == False and ema == True:\n",
        "        EMAbacktest(ticker)\n",
        "    else:        \n",
        "        df = get_data(ticker)\n",
        "        print(\"generate signals for stoch\")\n",
        "    #     print(df)\n",
        "        df = stochastic(df)\n",
        "        df = implement_stoch_strategy(df)\n",
        "        print(\"generate signals for stochRSI\")\n",
        "        df = stochRSI(df)\n",
        "        df = implement_stochRSI_strategy(df)\n",
        "        print(\"generate signals for ema\")\n",
        "        df = implement_ema_strategy(df)\n",
        "        df['nextDayClose'] = df['Close'].shift(-1)\n",
        "\n",
        "        stoch_signal_list = list(df['Stoch Signal'])\n",
        "        stochRSI_signal_list = list(df['Stoch RSI Signal'])\n",
        "        ema_signal_list = list(df['EMA Signal'])\n",
        "        \n",
        "        positions = []\n",
        "        buyDates = []\n",
        "        if len(stoch_signal_list)!=len(stochRSI_signal_list) or len(stochRSI_signal_list)!=len(ema_signal_list) or len(stoch_signal_list)!=len(ema_signal_list):\n",
        "            print(\"Some Error\")\n",
        "            return\n",
        "\n",
        "        for i in range(len(stoch_signal_list)):\n",
        "            if stoch == True and stoch_RSI == True and ema == True:\n",
        "                positions.append([stoch_signal_list[i], stochRSI_signal_list[i], ema_signal_list[i]])\n",
        "            elif stoch == True and stoch_RSI == True and ema == False:\n",
        "                positions.append([stoch_signal_list[i], stochRSI_signal_list[i]])\n",
        "            elif stoch == False and stoch_RSI == True and ema == True:\n",
        "                positions.append([stochRSI_signal_list[i], ema_signal_list[i]])\n",
        "            elif stoch == True and stoch_RSI == False and ema == True:\n",
        "                positions.append([stoch_signal_list[i], ema_signal_list[i]])\n",
        "        \n",
        "#         for i in range(len(positions)-10):\n",
        "#             p = np.array(positions[i:i+lookback_period])\n",
        "#             p[p<=0]=0\n",
        "#             print(\"n\", p)\n",
        "#             if sum(p[:,0])>=1 and sum(p[:,1])>=1 and sum(p[:,2])>=1: \n",
        "#                 print(True)\n",
        "#         print(\"Hi\", max(df['Time'][9:100]))\n",
        "    \n",
        "        if lookback_period == 1:       \n",
        "            for i in range(len(positions)):\n",
        "                if stoch == True and stoch_RSI == True and ema == True and positions[i]==[1,1,1.0]:\n",
        "                    buyDates.append(df['Timestamp'][i])\n",
        "                elif stoch == True and stoch_RSI == True and ema == False and positions[i]==[1,1]:\n",
        "                    buyDates.append(df['Timestamp'][i])\n",
        "                elif stoch == False and stoch_RSI == True and ema == True and positions[i]==[1,1.0]:\n",
        "                    buyDates.append(df['Timestamp'][i])\n",
        "                elif stoch == True and stoch_RSI == False and ema == True and positions[i]==[1,1.0]:\n",
        "                    buyDates.append(df['Timestamp'][i])\n",
        "        else:\n",
        "            for i in range(len(positions)-lookback_period):\n",
        "                p = np.array(positions[i:i+lookback_period])\n",
        "                p[p<=0]=0\n",
        "                if stoch == True and stoch_RSI == True and ema == True:\n",
        "                    if sum(p[:,0])>=1 and sum(p[:,1])>=1 and sum(p[:,2])>=1:\n",
        "                        buyDates.append(max(df['Timestamp'][i:i+lookback_period]))\n",
        "                else:\n",
        "                    if sum(p[:,0])>=1 and sum(p[:,1])>=1:\n",
        "                        buyDates.append(max(df['Timestamp'][i:i+lookback_period]))\n",
        "\n",
        "        buyDate = None\n",
        "        buyDateClose = None\n",
        "        investment_value = investment_amount\n",
        "        finalInvestmentValue = investment_amount\n",
        "        number_of_stocks = None\n",
        "        newStockValueForTrailing = None\n",
        "        trailing_stop_loss_at = activate_trailing_stop_loss_at\n",
        "        changeInInvestmentValue = None\n",
        "#         buys = []\n",
        "        sells = []\n",
        "        soldAtLast = True\n",
        "\n",
        "        for i in range(0,df.shape[0]):\n",
        "            if buyDates.count(df['Timestamp'][i]) == 1 and buyDate==None and buyDateClose==None:\n",
        "                buyDate = df['Timestamp'][i]\n",
        "                buyDateClose = df['Close'][i]\n",
        "                number_of_stocks = floor(finalInvestmentValue/buyDateClose)\n",
        "                finalInvestmentValue -= number_of_stocks*buyDateClose\n",
        "#                 buys.append(finalInvestmentValue)\n",
        "                newStockValueForTrailing = buyDateClose*((100+trailing_stop_loss_at)/100)\n",
        "                soldAtLast = False\n",
        "#                 print(i, \"stocks bought\", number_of_stocks, \"cost\", number_of_stocks*buyDateClose, \"total\", finalInvestmentValue)\n",
        "\n",
        "            if buyDate!=None and buyDateClose!=None:\n",
        "                if df['Close'][i]<=((100-stop_loss)/100)*buyDateClose or df['Close'][i]>=((100+limit_price)/100)*buyDateClose:\n",
        "                    ##direct sell\n",
        "                    finalInvestmentValue += number_of_stocks*df['Close'][i]\n",
        "                    sells.append(finalInvestmentValue)\n",
        "#                     print(i, \"direct stocks sold\", number_of_stocks, \"cost\", number_of_stocks*df['Close'][i], \"total\", finalInvestmentValue)\n",
        "                    buyDate=None\n",
        "                    buyDateClose=None\n",
        "                    soldAtLast = True\n",
        "                elif df['Close'][i]>=newStockValueForTrailing:\n",
        "                    minStockValueForTrailing = df['Close'][i]*((100-trailing_stop)/100)\n",
        "                    maxStockValueForTrailing = df['Close'][i]*((100+limit_price)/100)\n",
        "                    if df['nextDayClose'][i]>=maxStockValueForTrailing or df['nextDayClose'][i]<minStockValueForTrailing:\n",
        "        #                 number_of_stocks = floor(finalInvestmentValue/df['Close'][i])\n",
        "                        finalInvestmentValue += number_of_stocks*df['Close'][i]\n",
        "                        sells.append(finalInvestmentValue)\n",
        "#                         print(i, \"stocks sold\", number_of_stocks, \"cost\", number_of_stocks*df['Close'][i], \"total\", finalInvestmentValue)\n",
        "                        buyDate=None\n",
        "                        buyDateClose=None\n",
        "                        soldAtLast = True\n",
        "                        \n",
        "#         print(soldAtLast, sells)\n",
        "        # Timeframe = {}\n",
        "        # Start Date = {}\n",
        "        # End Date = {}\n",
        "        # Lookback Period = {}\n",
        "        # Stop Loss = {}\n",
        "        # Trailing Stop Loss activates at: {}\n",
        "        # Trailing Stop Loss = {}\n",
        "        if len(buyDates) != 0:\n",
        "          startDate = buyDates[1].strftime(\"%Y-%m-%d %H:%M:%s\")\n",
        "          endDate = buyDates[-1].strftime(\"%Y-%m-%d %H:%M:%s\")\n",
        "        else:\n",
        "          startDate = None\n",
        "          endDate = None\n",
        "\n",
        "        print('Parameters for backtesting, Stoch:{}, StochRSI:{}, EMA:{}'.format(stoch, stoch_RSI, ema))\n",
        "        print('Timeframe: {}, \\nStart Date: {}, \\nEnd Date: {}, \\nLookback Period: {}, \\nStop Loss: {}, \\nTrailing Stop Loss activates at: {}, \\nTrailing Stop Loss: {}'.format(timeframe, startDate, endDate, lookback_period, stop_loss, activate_trailing_stop_loss_at, trailing_stop))\n",
        "        if soldAtLast:\n",
        "            changeInInvestmentValue =  ((finalInvestmentValue - investment_value)/investment_value)*100\n",
        "            print('Total Investment Remaining: {}'.format(finalInvestmentValue))\n",
        "            print('Profit gained from the strategy by investing $100k in {} : {}'.format(ticker, finalInvestmentValue-investment_value))\n",
        "        else:\n",
        "            changeInInvestmentValue =  ((sells[-1] - investment_value)/investment_value)*100\n",
        "            print('Total Investment Remaining: {}'.format(sells[-1]))\n",
        "            print('Profit gained from the strategy by investing $100k in {} : {}'.format(ticker, sells[-1]-investment_value))\n",
        "        \n",
        "        print('Profit percentage of the strategy : {}%'.format(changeInInvestmentValue))\n"
      ],
      "metadata": {
        "id": "7JJdtHzMj5xZ"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "fDzJJknVo9lN"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Backtesting"
      ],
      "metadata": {
        "id": "FVAem_8Ekv0s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stoch_StochRSI_EMA_Backtest('ETHUSD', stoch= False, stoch_RSI = True, ema= True, lookback_period=1)"
      ],
      "metadata": {
        "id": "MvkbgvpnkvMv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "034199b6-ce03-407f-e034-0c85bdc2ed40"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "generate signals for stoch\n",
            "generate signals for stochRSI\n",
            "generate signals for ema\n",
            "Parameters for backtesting, Stoch:False, StochRSI:True, EMA:True\n",
            "Timeframe: 1Hour, \n",
            "Start Date: 2022-02-08 02:00:1644285600, \n",
            "End Date: 2022-02-10 02:00:1644458400, \n",
            "Lookback Period: 1, \n",
            "Stop Loss: 2, \n",
            "Trailing Stop Loss activates at: 1, \n",
            "Trailing Stop Loss: 2\n",
            "Total Investment Remaining: 10770.069999999998\n",
            "Profit gained from the strategy by investing $100k in ETHUSD : 770.0699999999979\n",
            "Profit percentage of the strategy : 7.700699999999978%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "LNZZEzhQA6vE"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}