Trading Live BOT (3) .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BUY-SELL bot on Guppy indicator 4 colours "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* What is a Trading BOT ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Zerodha trading robot is a computer program based on a set of indian trading signals that helps determine whether to buy or sell a currency pair at a given point in time. Zerodha robots are designed to remove the psychological element of trading, which can be detrimental. While trading systems can be purchased online, traders should exercise caution when buying them this way."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trading bots are widely available programs that connect to a user’s indian exchange and make trades on their behalf. They work using a variety of indicators and signals, such as moving averages and indices. The idea is simple: to help users make money in the markets, while not wasting a lot of their time. The underlying assumption is that computers are much better at trading than humans could ever be, because trading is all about mathematics and complex calculations of probability."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* About this Trading BOT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the automated BUY and SELL code for zerodha , it will first scan all the tokens on guppy indicator using screener on 5 minute 15 minute and 30 minute and shows the result of buy sell from all 3 timeframe and after the token which is high priority of buy /sell will sort out and then we have to select on which stock we want to rrun our bot at which timefrme quantity and exchange. we can place order any stock which we want . "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* * * * "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  GUPPY CONCEPT  FOR THIS BOT?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if GREEN:\n",
    "\n",
    "    buy x amount                 -------------------------------------------------(A)\n",
    "    \n",
    "if BLUE:\n",
    "\n",
    "    check exection of (A)\n",
    "    if (A) executed : SELL X/2               ------------------------------------(Z)\n",
    "    \n",
    "if RED:\n",
    "\n",
    "    if A executed: SELL 2X                                ------------------------(B)\n",
    "    if A not exeecuted - cancel (A)\n",
    "                         sell X amount                    ------------------------(C)\n",
    "\n",
    "@ ** if will execute only when BLUE occurs , if Z bit is placed **\n",
    "\n",
    "Check execution of B:\n",
    "\n",
    "    if (B) executed + if (Z) executed : SELL x/2 --------------- (Y)\n",
    "    if (B) executed and if (Z) not executed : cancel (Z)   \n",
    "\n",
    "if AQUA:\n",
    "\n",
    "    if (B) executed : BUY x/2    (MARKET)                   ---------------------(D)\n",
    "    if (C) executed : BUY x/2    (MARKET)                  ----------------------(E)\n",
    "\n",
    "if GREEN:\n",
    "    \n",
    "    (PART A)\n",
    "        if (B) executed : BUY 2X                           -----------------------(F)\n",
    "            if (B) not executed:\n",
    "            cancel (B), and wait for RED\n",
    "            \n",
    "    (PART B)\n",
    "         if (C) executed : BUY 2X                         ------------------------(G)\n",
    "         if (C) not executed: \n",
    "            cancel (C) , and wait for RED   \n",
    "\n",
    "    \n",
    "@ ** if will execute only when AQUA occurs **\n",
    "Check execution of G or F:\n",
    "    (CASE A)\n",
    "    \n",
    "          if (F) executed + if (D) executed : SELL x/2           --------------- (H)\n",
    "          if (F) executed and if (D) not executed : cancel (D)   \n",
    "\n",
    "    (CASE B)\n",
    "        if (G) executed + if (E) executed : SELL x/2              --------------- (I)\n",
    "        if (G) executed and if (E) not executed : cancel (E)   \n",
    "            \n",
    "            \n",
    "if BLUE:\n",
    "\n",
    "    if (F) executed: SELL x/2  (MARKET)\n",
    "    if (G) executed : SELL x/2 (MARKET)\n",
    "    \n",
    "if RED:\n",
    "    continue from red again:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Login To zerodha "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"  \\t \\t \\t \\t \\t  \\n WELCOME to 'GUPPY BOT' Please wait while we are installing library\")\n",
    "print(\"\\n\")\n",
    "import time\n",
    "import secrets \n",
    "import threading\n",
    "import webbrowser\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from pytz import timezone\n",
    "from math import modf\n",
    "from pprint import pprint\n",
    "from datetime import datetime\n",
    "from time import gmtime, strftime\n",
    "from kiteconnect import KiteTicker \n",
    "from kiteconnect import KiteConnect\n",
    "from IPython.display import clear_output\n",
    "#\n",
    "# API your KEY and API secter \n",
    "\n",
    "api_key='******************* @@enter your api key here@@@**************' \n",
    "api_secret='**********************@@enter your api key here****************'\n",
    "\n",
    "webbrowser.open_new_tab(KiteConnect(api_key,api_secret).login_url())\n",
    "kite = KiteConnect(api_key=api_key)\n",
    "data = kite.generate_session(((str(input(\"ENTER full link generated in URL :- \")).split(\"request_token=\")[1]).split(\"&action\"))[0],api_secret)\n",
    "kite.set_access_token(data[\"access_token\"])\n",
    "print(\" \\n \")\n",
    "display(data)\n",
    "print(\"  \\t \\t \\t \\t \\t  WELCOME TO GUPPY BOT \")\n",
    "print(\"\\n\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementation of  Coding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " \t \t \t \t Zerodha GUPPY SCREENER for 30 minute Data\n",
      "\n",
      "\n",
      "\t \t \t \n",
      " Current Token checking   975873\n",
      "\n",
      "\n",
      " \t \t \t \n",
      " Current Colour on this token is  none\n",
      "Buy stock found for 30 minute are  := [81153, 424961]\n",
      "Sell stocks found for 30 minute are:= []\n",
      "SCANNING COMPLETE\n",
      "5 ,15 and 30 are completed ! Results are \n",
      "\n",
      "\n",
      "tokens we get on 5 minute BUY   [784129]\n",
      "tokens we get on 5 minute SELL  []\n",
      "\n",
      "\n",
      "tokens we get on 15 minute BUY   [1207553, 2977281, 784129]\n",
      "tokens we get on 15 minute SELL  []\n",
      "\n",
      "\n",
      "tokens we get on 30 minute BUY   [81153, 424961]\n",
      "tokens we get on 30 minute SELL  []\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "BUY from ALL   {784129, 2977281, 1207553, 81153, 424961}\n",
      "SELL From ALL  set()\n",
      "\n",
      "\n",
      "  \t \t \t \t \tBUY | SELL on 5 MINUTE\n",
      "BUY\n",
      "['VEDL']\n",
      "SELL\n",
      "[]\n",
      "\n",
      "\n",
      " \t \t \t \t \t BUY | SELl on 15 minute\n",
      "BUY\n",
      "['GAIL', 'NTPC', 'VEDL']\n",
      "SELL\n",
      "[]\n",
      "\n",
      "\n",
      " \t \t \t \t \t BUY | SELl on 30 minute\n",
      "BUY\n",
      "['BAJFINANCE', 'ITC']\n",
      "SELL\n",
      "[]\n",
      " \n",
      " \n",
      " \t \t \t \t \t OVERALL BUY  SELL \n",
      " \n",
      " \n",
      " OVERALL -  BUY  ['VEDL'] ['GAIL', 'NTPC', 'VEDL'] ['BAJFINANCE', 'ITC']\n",
      " OVERALL - SELL [] [] []\n",
      " \n",
      " \n",
      " \t \t \t \t \t COMMON BUY-SELL After filter \n",
      " OVERALL BUY []\n",
      " OVERALL SELL ['VEDL', 'NTPC', 'GAIL', 'BAJFINANCE', 'ITC']\n",
      "\t \t \t \t \t !! ALL COMPLETED !!\n",
      " \n",
      " \n",
      "WELCOME TO GUPPY BOT ! ENTER 'BUY' or 'SELL', which you want\n",
      " ENTER BUY or SELL :-buy\n",
      " ** ENTER ALL DETAILS IN CAPITAL LETTERS ONLY **\n",
      "ENTER TRADINGSYMBOL - SUNPHARMA / SBIN :-ITC\n",
      "ENTER EXCHANGE / NSE / BSE / CDS  :-NSE\n",
      "ENTER PRODUCT / NRML /CNC / MIS  :-CNC\n",
      "ENTER QUANTITY - 2 / 4 :-40\n",
      "ENTER TIME_FRAME - minute / 5minute **SMALL letters only** :-5minute\n",
      "BOT STARTED WITH GREEN 'BUY' ENTRY after scanning \n",
      " \n",
      " \t \t \t \t  ZERODHA GUPPY BOT \n",
      " \t \t \t \n",
      " Current Colour on this token is  none\n",
      "\n",
      " \n",
      "Zerodha GUPPY BOT start Time              2019-08-31 _ 22:51:17 \n",
      "\n",
      " \n",
      "BOT working succeesfully on time:         2019-08-31 _ 22:51:17 \n",
      "\n",
      " \n",
      "Trading symbol is ITC Token is 424961 Exchange is NSE and product type is CNC Quantity is 40 time frame for Historical Data is 5minute Starting and Ending Date of Historical Data is 2019-06-05 2020-10-02\n",
      "\n",
      " \n",
      "\n",
      " \n",
      "Colours Till Now\n",
      "['none']\n",
      " \n",
      " \t \t \t \t  ZERODHA GUPPY BOT \n",
      " \t \t \t \n",
      " Current Colour on this token is  none\n",
      "\n",
      " \n",
      "Zerodha GUPPY BOT start Time              2019-08-31 _ 22:51:17 \n",
      "\n",
      " \n",
      "BOT working succeesfully on time:         2019-08-31 _ 22:52:14 \n",
      "\n",
      " \n",
      "Trading symbol is ITC Token is 424961 Exchange is NSE and product type is CNC Quantity is 40 time frame for Historical Data is 5minute Starting and Ending Date of Historical Data is 2019-06-05 2020-10-02\n",
      "\n",
      " \n",
      "\n",
      " \n",
      "Colours Till Now\n",
      "['none', 'none']\n",
      " \n",
      " \t \t \t \t  ZERODHA GUPPY BOT \n",
      " \t \t \t \n",
      " Current Colour on this token is  none\n",
      "\n",
      " \n",
      "Zerodha GUPPY BOT start Time              2019-08-31 _ 22:51:17 \n",
      "\n",
      " \n",
      "BOT working succeesfully on time:         2019-08-31 _ 22:53:15 \n",
      "\n",
      " \n",
      "Trading symbol is ITC Token is 424961 Exchange is NSE and product type is CNC Quantity is 40 time frame for Historical Data is 5minute Starting and Ending Date of Historical Data is 2019-06-05 2020-10-02\n",
      "\n",
      " \n",
      "\n",
      " \n",
      "Colours Till Now\n",
      "['none', 'none', 'none']\n",
      " \n",
      " \t \t \t \t  ZERODHA GUPPY BOT \n",
      " \t \t \t \n",
      " Current Colour on this token is  none\n",
      "\n",
      " \n",
      "Zerodha GUPPY BOT start Time              2019-08-31 _ 22:51:17 \n",
      "\n",
      " \n",
      "BOT working succeesfully on time:         2019-08-31 _ 22:54:15 \n",
      "\n",
      " \n",
      "Trading symbol is ITC Token is 424961 Exchange is NSE and product type is CNC Quantity is 40 time frame for Historical Data is 5minute Starting and Ending Date of Historical Data is 2019-06-05 2020-10-02\n",
      "\n",
      " \n",
      "\n",
      " \n",
      "Colours Till Now\n",
      "['none', 'none', 'none', 'none']\n"
     ]
    }
   ],
   "source": [
    "print(\"  \\t \\t \\t \\t \\t \\n WELCOME TO GUPPY BOT \")\n",
    "print(\"\\n\" )\n",
    "\n",
    "scan=str(input(\"DO you want Scanning ? YES/NO :-\"))\n",
    "\n",
    "\n",
    "if \"YES\"==scan or \"yes\"==scan:\n",
    "    # for SCANNING OF STOCKS\n",
    "    \n",
    "    print(\"SCANNING START\")\n",
    "\n",
    "    # all nifty_50 symbols\n",
    "    \n",
    "    z=['ADANIPORTS', 'ASIANPAINT', 'AXISBANK', 'BAJAJ-AUTO', 'BAJFINANCE', 'BAJAJFINSV', 'BPCL', 'BHARTIARTL', 'INFRATEL', 'BRITANNIA', 'CIPLA', 'COALINDIA', 'DRREDDY', 'EICHERMOT', 'GAIL', 'GRASIM', 'HCLTECH', 'HDFCBANK', 'HEROMOTOCO', 'HINDALCO', 'HINDUNILVR', 'HDFC', 'ICICIBANK', 'ITC', 'IBULHSGFIN', 'IOC', 'INDUSINDBK', 'INFY', 'JSWSTEEL', 'KOTAKBANK', 'LT', 'M&M', 'MARUTI', 'NTPC', 'ONGC', 'POWERGRID', 'RELIANCE', 'SBIN', 'SUNPHARMA', 'TCS', 'TATAMOTORS', 'TATASTEEL', 'TECHM', 'TITAN', 'UPL', 'ULTRACEMCO', 'VEDL', 'WIPRO', 'YESBANK', 'ZEEL']\n",
    "# INPUTS FOR THE BOT\n",
    "\n",
    "    eexchange=\"NSE\"\n",
    "    time_frame     =\"5minute\"\n",
    "    sdate          =\"2018-02-28\"\n",
    "    todate         =\"2019-08-31\"\n",
    "    tokenall=[]\n",
    "    aa=0\n",
    "    print(\"  \\t \\t \\t \\n Getting All tokens for processing BUY SELL \")\n",
    "    # FETCHING ALL TOKENS FROM SYMBOL\n",
    "    while(True):\n",
    "        ttoken=int(pd.DataFrame(kite.ltp(eexchange+\":\"+z[aa])).iloc[-2,0])\n",
    "        tokenall.append(ttoken)\n",
    "        aa=aa+1\n",
    "        if aa==50:\n",
    "            print(\"  \\t \\t \\t \\n Complete ! All tokens are fetched from file \")\n",
    "            print(\"\\n\" )\n",
    "            print(tokenall)\n",
    "            break\n",
    "    print(\" Now checking Condition of BUY sell of GUPPY \")\n",
    "    #Variables\n",
    "    buy5minute=[]\n",
    "    sell5minute=[]\n",
    "    buy10minute=[]\n",
    "    sell10minute=[]\n",
    "    buy15minute=[]\n",
    "    sell15minute=[]\n",
    "    ##\n",
    "    lst_candle=[]\n",
    "    lst_heikin_nor=[]\n",
    "    lst_heikin=[]\n",
    "    lst_cand=[]\n",
    "    lst_c=[]\n",
    "    anchor=0\n",
    "    countstart=0\n",
    "    #programe start\n",
    "    a=0\n",
    "    BUY_listindicator=[]\n",
    "    SELL_listindicator=[]\n",
    "    print(a)\n",
    "    \n",
    "    def ashi():\n",
    "        global a\n",
    "        global BUY_listindicator\n",
    "        global SELL_listindicator\n",
    "        # INDICATOR\n",
    "        \n",
    "        while(True):\n",
    "                print(\"\\n\" )\n",
    "                print(\"Current Token Number which is processing is\",a)\n",
    "            #km=datetime.now().minute\n",
    "            #ks=datetime.now().second\n",
    "            #if km%1==0 and ks==1:\n",
    "                clear_output(wait=True)  \n",
    "                now_utc = datetime.now(timezone('UTC'))\n",
    "                now_asia = now_utc.astimezone(timezone('Asia/Kolkata'))\n",
    "                now_asia = now_asia.strftime(\"%S \")\n",
    "                klp1=now_asia\n",
    "                #df=kite.historical_data(140033,sdate,todate,time_frame,0)\n",
    "                dff=kite.historical_data(tokenall[a],sdate,todate,time_frame,0)\n",
    "                dfw=pd.DataFrame(dff)\n",
    "                df=pd.DataFrame(dfw[['date','open','high','low','close']])\n",
    "                slow_ema = [3,5,7,9,11,13,15,17,19,21,23]\n",
    "                fast_ema = [25,28,31,34,37,40,43,46,49,52,55,58,61,64,67,70,200]\n",
    "                def EMA(df, base, target, period, alpha=False):\n",
    "                    con = pd.concat([df[:period][base].rolling(window=period).mean(), df[period:][base]])\n",
    "                    if (alpha == True):\n",
    "                        # (1 - alpha) * previous_val + alpha * current_val where alpha = 1 / period\n",
    "                        df[target] = con.ewm(alpha=1 / period, adjust=False).mean()\n",
    "                    else:\n",
    "                        # ((current_val - previous_val) * coeff) + previous_val where coeff = 2 / (period + 1)\n",
    "                        df[target] = con.ewm(span=period, adjust=False).mean()\n",
    "                    df.fillna(0,inplace = True)\n",
    "                #     return df\n",
    "                for j in slow_ema:\n",
    "                    val = \"ema\"+\"_\"+str(j)\n",
    "                    EMA(df,\"close\",val,j)\n",
    "                for k in fast_ema:\n",
    "                    val = \"ema\"+\"_\"+str(k)\n",
    "                    EMA(df,\"close\",val,k)\n",
    "                def super_guppy(interval,df,anchor=0):\n",
    "                #     df['buy'] = 0\n",
    "                #     df['sell'] = 0\n",
    "                #     df['buybreak'] = 0\n",
    "                #     df['sellbreak'] = 0\n",
    "                    anchor = 0\n",
    "                    ShowBreak = True\n",
    "                    ShowSwing = True\n",
    "                    ShowCon = False\n",
    "                    uOCCswing = False\n",
    "                    Lookback = 6\n",
    "                    emaFilter = False\n",
    "                    mult = 0\n",
    "                    buybreak = 0\n",
    "                    sellbreak = 0\n",
    "                    buy_barssince_var = 0\n",
    "                    sell_barssince_var = 0\n",
    "                    buybreak_barssince_var = 0\n",
    "                    sellbreak_barssince_var = 0\n",
    "                    barssince_lst = list()\n",
    "                    barssince_var = 0\n",
    "                    bar_count_var = 0\n",
    "                    buy1 = list()\n",
    "                    sell1 = list()\n",
    "                    buy2 = list()\n",
    "                    sell2 = list()\n",
    "                    buybreak1 = list()\n",
    "                    sellbreak1 = list()\n",
    "                    def barssince(b,barssince_var):\n",
    "                        barssince_lst = []\n",
    "                        barssince_var = 0 \n",
    "                        new_var = len(b)\n",
    "                        for i in b[::-1]:\n",
    "                            if i == 1:\n",
    "                                break\n",
    "                            barssince_lst.append(i)\n",
    "                        barssince_var = len(barssince_lst)\n",
    "                        return barssince_var\n",
    "                        barssince_lst.clear()\n",
    "                    #isIntraday\n",
    "                    if interval < 1441 :\n",
    "                        if (anchor==0 or interval <= 0 or interval >= anchor or anchor > 1441 ):\n",
    "                            mult = 1\n",
    "                        else:\n",
    "                            if round(anchor/interval) > 1:\n",
    "                                mult = round(anchor/interval)\n",
    "                            else:\n",
    "                                mult = 1\n",
    "                    else:\n",
    "                        mult = 1\n",
    "                    #isIntraday Not\n",
    "                    if interval > 1441:\n",
    "                        if (anchor==0 or interval <= 0 or interval >= anchor or anchor < 52 ):\n",
    "                            mult = mult\n",
    "                        else:\n",
    "                            if round(anchor/interval) > 1:\n",
    "                                mult = round(anchor/interval)\n",
    "                            else:\n",
    "                                mult = 1\n",
    "                    else:\n",
    "                        mult = mult\n",
    "                    mult = 1\n",
    "                    for i in range(len(df)):\n",
    "                        emaF1 = df.loc[i,'ema_3']\n",
    "                        emaF2 = df.loc[i,'ema_5']\n",
    "                        emaF3 = df.loc[i,'ema_7']\n",
    "                        emaF4 = df.loc[i,'ema_9']\n",
    "                        emaF5 = df.loc[i,'ema_11']\n",
    "                        emaF6 = df.loc[i,'ema_13']\n",
    "                        emaF7 = df.loc[i,'ema_15']\n",
    "                        emaF8 = df.loc[i,'ema_17']\n",
    "                        emaF9 = df.loc[i,'ema_19']\n",
    "                        emaF10 = df.loc[i,'ema_21']\n",
    "                        emaF11 = df.loc[i,'ema_23']\n",
    "                        emaS1 = df.loc[i,'ema_25']\n",
    "                        emaS2 = df.loc[i,'ema_28']\n",
    "                        emaS3 = df.loc[i,'ema_31']\n",
    "                        emaS4 = df.loc[i,'ema_34']\n",
    "                        emaS5 = df.loc[i,'ema_37']\n",
    "                        emaS6 = df.loc[i,'ema_40']\n",
    "                        emaS7 = df.loc[i,'ema_43']\n",
    "                        emaS8 = df.loc[i,'ema_46']\n",
    "                        emaS9 = df.loc[i,'ema_49']\n",
    "                        emaS10 = df.loc[i,'ema_52']\n",
    "                        emaS11 = df.loc[i,'ema_55']\n",
    "                        emaS12 = df.loc[i,'ema_58']\n",
    "                        emaS13 = df.loc[i,'ema_61']\n",
    "                        emaS14 = df.loc[i,'ema_64']\n",
    "                        emaS15 = df.loc[i,'ema_67']\n",
    "                        emaS16 = df.loc[i,'ema_70']\n",
    "                        ema200 = df.loc[i,'ema_200'] \n",
    "                        emafast = (emaF1 + emaF2 + emaF3 + emaF4 + emaF5 + emaF6 + emaF7 + emaF8 + emaF9 + emaF10 + emaF11)/11\n",
    "                        emaslow = (emaS1 + emaS2 + emaS3 + emaS4 + emaS5 + emaS6 + emaS7 + emaS8 + emaS9 + emaS10 + emaS11 + emaS12 + emaS13 + emaS14 + emaS15 + emaS16)/16\n",
    "                        #Fast EMA Color Rules\n",
    "                        colfastL = (emaF1>emaF2 and emaF2>emaF3 and emaF3>emaF4 and emaF4>emaF5 and emaF5>emaF6 and emaF6>emaF7 and emaF7>emaF8 and emaF8>emaF9 and emaF9>emaF10 and emaF10>emaF11)\n",
    "                        colfastS = (emaF1<emaF2 and emaF2<emaF3 and emaF3<emaF4 and emaF4<emaF5 and emaF5<emaF6 and emaF6<emaF7 and emaF7<emaF8 and emaF8<emaF9 and emaF9<emaF10 and emaF10<emaF11)\n",
    "                        #Slow EMA Color Rules\n",
    "                        colslowL = (emaS1>emaS2 and emaS2>emaS3 and emaS3>emaS4 and emaS4>emaS5 and emaS5>emaS6 and emaS6>emaS7 and emaS7>emaS8) and (emaS8>emaS9 and emaS9>emaS10 and emaS10>emaS11 and emaS11>emaS12 and emaS12>emaS13 and emaS13>emaS14 and emaS14>emaS15 and emaS15>emaS16)\n",
    "                        colslowS = (emaS1<emaS2 and emaS2<emaS3 and emaS3<emaS4 and emaS4<emaS5 and emaS5<emaS6 and emaS6<emaS7 and emaS7<emaS8) and (emaS8<emaS9 and emaS9<emaS10 and emaS10<emaS11 and emaS11<emaS12 and emaS12<emaS13 and emaS13<emaS14 and emaS14<emaS15 and emaS15<emaS16)\n",
    "                        if  emafast > emaslow and not colslowS and colfastL and (not ShowCon or colslowL) and (not emaFilter or emafast>ema200):\n",
    "                            if int(buy1[-1]) > 0:\n",
    "                                buy = buy1[-1] + 1\n",
    "                            else:\n",
    "                                buy = 1\n",
    "                        else:\n",
    "                            buy = 0\n",
    "                        buy1.append(buy)\n",
    "                        if  emafast < emaslow and not colslowL and colfastS and (not ShowCon or colslowS) and (not emaFilter or emafast<ema200):\n",
    "                            if int(sell1[-1]) > 0:\n",
    "                                sell = sell1[-1] + 1\n",
    "                            else:\n",
    "                                sell = 1\n",
    "                        else:\n",
    "                            sell = 0\n",
    "                        sell1.append(sell)\n",
    "                        #buy\n",
    "                        if buy>1 and colfastL and (uOCCswing and ((df.loc[i-1,'close']<df.loc[i-1,'open']) and (df.loc[i,'close']>df.loc[i,'open']))):\n",
    "                            buy3 = 1\n",
    "                        else:\n",
    "                            buy3 = buy\n",
    "                        buy2.append(buy3)\n",
    "                        #sell    \n",
    "                        if sell>1 and colfastS and (uOCCswing and ((df.loc[i-1,'close']<df.loc[i-1,'open']) and (df.loc[i,'close']>df.loc[i,'open']))):\n",
    "                            sell3 = 1\n",
    "                        else:\n",
    "                            sell3 = sell\n",
    "                        sell2.append(sell3)\n",
    "                        #buybreak\n",
    "                        if emafast > emaslow and not colslowS and (not emaFilter or emafast>ema200):\n",
    "                            if buybreak1[-1] > 0:\n",
    "                                buybreak = buybreak1[-1] + 1\n",
    "                            else:\n",
    "                                buybreak = 1\n",
    "                        else:\n",
    "                            buybreak = 0\n",
    "                        buybreak1.append(buybreak)\n",
    "                        if emafast < emaslow and not colslowL and (not emaFilter or emafast<ema200):\n",
    "                            if sellbreak1[-1] > 0:\n",
    "                                sellbreak = sellbreak1[-1]+1\n",
    "                            else:\n",
    "                                sellbreak = 1\n",
    "                        else:\n",
    "                            sellbreak = 0\n",
    "                        sellbreak1.append(sellbreak)\n",
    "                        #arrow plotting\n",
    "                        #buy_arrow\n",
    "                        buy_barssince_var = barssince(buy2[:-1],barssince_var)\n",
    "                        if (ShowSwing and buy3==1)and buy_barssince_var > 6:\n",
    "                            buy_arrow = 1\n",
    "                        else:\n",
    "                            buy_arrow = 0\n",
    "                        #sell arrow\n",
    "                        sell_barssince_var = barssince(sell2[:-1],barssince_var)\n",
    "                        if ShowSwing and (sell3==1 and sell_barssince_var > 6):\n",
    "                            sell_arrow = 1\n",
    "                        else:\n",
    "                            sell_arrow = 0\n",
    "                        #buybreak_arrow\n",
    "                        buybreak_barssince_var = barssince(buybreak1[:-1],barssince_var)\n",
    "                        sellbreak_barssince_var = barssince(sellbreak1[:-1],barssince_var)\n",
    "\n",
    "                        if ShowBreak and buybreak==1 and (sellbreak_barssince_var>Lookback) and (buybreak_barssince_var>Lookback):\n",
    "                            buybreak_arrow = 1\n",
    "                        else:\n",
    "                            buybreak_arrow = 0\n",
    "                        #sellbreak_arrow\n",
    "                        if ShowBreak and sellbreak==1 and (buybreak_barssince_var>Lookback) and (sellbreak_barssince_var>Lookback):\n",
    "                            sellbreak_arrow = 1\n",
    "                        else:\n",
    "                            sellbreak_arrow = 0\n",
    "                        if buy_arrow==1 and sell_arrow==0 and buybreak_arrow==0 and sellbreak_arrow==0:\n",
    "                            arrow_color = 'green'\n",
    "                        elif buy_arrow==0 and sell_arrow==1 and buybreak_arrow==0 and sellbreak_arrow==0:\n",
    "                            arrow_color = 'red'\n",
    "                        elif sell_arrow==0 and (buy_arrow==0 or buy_arrow==1) and buybreak_arrow==1 and sellbreak_arrow==0:\n",
    "                            arrow_color = 'aqua'\n",
    "                        elif buy_arrow==0 and (sell_arrow==1 or sell_arrow==0) and buybreak_arrow==0 and sellbreak_arrow==1:\n",
    "                            arrow_color = 'blue'\n",
    "                        else:\n",
    "                            arrow_color = 'none'\n",
    "                        df.loc[i,'arrow_color'] = arrow_color\n",
    "                    df = df[['date','open','high','low','close','arrow_color']]\n",
    "                    return df\n",
    "                df=super_guppy(15,df)\n",
    "                gup=df\n",
    "                # \n",
    "                print(\" \\t \\t \\t \\t Zerodha GUPPY SCREENER on 5 minute Data\")\n",
    "                print(\"\\t \\t \\t \\n Current Token checking  \" , tokenall[a])\n",
    "                print(\"\\n\" )\n",
    "                print(\" \\t \\t \\t \\n Current Colour on this token is \" , gup.iloc[-1,5])\n",
    "                if \"green\" in gup.iloc[-1,5]:\n",
    "                    print(\" BUY stock found \")\n",
    "                    buy5minute.append((tokenall[a]))\n",
    "                if \"red\" in gup.iloc[-1,5]:\n",
    "                    print(\" SELL stock found \")\n",
    "                    sell5minute.append((tokenall[a]))\n",
    "                else:\n",
    "                    pass\n",
    "                print(\"Buy stock found for 5 minute are  :=\"  ,buy5minute)\n",
    "                print(\"Sell stocks found for 5 minute are:=\"  ,sell5minute)\n",
    "                a=a+1\n",
    "                if a==len(tokenall): # ALL TOKENS ARE SCANNED\n",
    "                    \n",
    "                    file=str(buy5minute)\n",
    "                    filee=str(sell5minute)\n",
    "                    with open(\"tokens.txt\",\"w\") as  f:\n",
    "                        f.write(file)\n",
    "                        f.write(filee)\n",
    "                    break\n",
    "                \n",
    "    ashi()\n",
    "    \n",
    "    # START SCANNINF FOR FIRST 5 MINUTE TOKEN BUY/SELL\n",
    "    \n",
    "    print(\"5 minute data complete! Now getting Data of 15 minutes \")\n",
    "    time_frame     =\"15minute\"\n",
    "    a=0\n",
    "    def ashi15():\n",
    "        global a\n",
    "        global BUY_listindicator\n",
    "        global SELL_listindicator\n",
    "        while(True):\n",
    "                print(\"\\n\" )\n",
    "                print(\"Current Token Number which is processing is\",a)\n",
    "            #km=datetime.now().minute\n",
    "            #ks=datetime.now().second\n",
    "            #if km%1==0 and ks==1:\n",
    "                clear_output(wait=True)  \n",
    "                now_utc = datetime.now(timezone('UTC'))\n",
    "                now_asia = now_utc.astimezone(timezone('Asia/Kolkata'))\n",
    "                now_asia = now_asia.strftime(\"%S \")\n",
    "                klp1=now_asia\n",
    "                #df=kite.historical_data(140033,sdate,todate,time_frame,0)\n",
    "                dff=kite.historical_data(tokenall[a],sdate,todate,time_frame,0)\n",
    "                dfw=pd.DataFrame(dff)\n",
    "                df=pd.DataFrame(dfw[['date','open','high','low','close']])\n",
    "                slow_ema = [3,5,7,9,11,13,15,17,19,21,23]\n",
    "                fast_ema = [25,28,31,34,37,40,43,46,49,52,55,58,61,64,67,70,200]\n",
    "                def EMA(df, base, target, period, alpha=False):\n",
    "                    con = pd.concat([df[:period][base].rolling(window=period).mean(), df[period:][base]])\n",
    "                    if (alpha == True):\n",
    "                        # (1 - alpha) * previous_val + alpha * current_val where alpha = 1 / period\n",
    "                        df[target] = con.ewm(alpha=1 / period, adjust=False).mean()\n",
    "                    else:\n",
    "                        # ((current_val - previous_val) * coeff) + previous_val where coeff = 2 / (period + 1)\n",
    "                        df[target] = con.ewm(span=period, adjust=False).mean()\n",
    "                    df.fillna(0,inplace = True)\n",
    "                #     return df\n",
    "                for j in slow_ema:\n",
    "                    val = \"ema\"+\"_\"+str(j)\n",
    "                    EMA(df,\"close\",val,j)\n",
    "                for k in fast_ema:\n",
    "                    val = \"ema\"+\"_\"+str(k)\n",
    "                    EMA(df,\"close\",val,k)\n",
    "                def super_guppy(interval,df,anchor=0):\n",
    "                #     df['buy'] = 0\n",
    "                #     df['sell'] = 0\n",
    "                #     df['buybreak'] = 0\n",
    "                #     df['sellbreak'] = 0\n",
    "                    anchor = 0\n",
    "                    ShowBreak = True\n",
    "                    ShowSwing = True\n",
    "                    ShowCon = False\n",
    "                    uOCCswing = False\n",
    "                    Lookback = 6\n",
    "                    emaFilter = False\n",
    "                    mult = 0\n",
    "                    buybreak = 0\n",
    "                    sellbreak = 0\n",
    "                    buy_barssince_var = 0\n",
    "                    sell_barssince_var = 0\n",
    "                    buybreak_barssince_var = 0\n",
    "                    sellbreak_barssince_var = 0\n",
    "                    barssince_lst = list()\n",
    "                    barssince_var = 0\n",
    "                    bar_count_var = 0\n",
    "                    buy1 = list()\n",
    "                    sell1 = list()\n",
    "                    buy2 = list()\n",
    "                    sell2 = list()\n",
    "                    buybreak1 = list()\n",
    "                    sellbreak1 = list()\n",
    "                    def barssince(b,barssince_var):\n",
    "                        barssince_lst = []\n",
    "                        barssince_var = 0 \n",
    "                        new_var = len(b)\n",
    "                        for i in b[::-1]:\n",
    "                            if i == 1:\n",
    "                                break\n",
    "                            barssince_lst.append(i)\n",
    "                        barssince_var = len(barssince_lst)\n",
    "                        return barssince_var\n",
    "                        barssince_lst.clear()\n",
    "                    #isIntraday\n",
    "                    if interval < 1441 :\n",
    "                        if (anchor==0 or interval <= 0 or interval >= anchor or anchor > 1441 ):\n",
    "                            mult = 1\n",
    "                        else:\n",
    "                            if round(anchor/interval) > 1:\n",
    "                                mult = round(anchor/interval)\n",
    "                            else:\n",
    "                                mult = 1\n",
    "                    else:\n",
    "                        mult = 1\n",
    "                    #isIntraday Not\n",
    "                    if interval > 1441:\n",
    "                        if (anchor==0 or interval <= 0 or interval >= anchor or anchor < 52 ):\n",
    "                            mult = mult\n",
    "                        else:\n",
    "                            if round(anchor/interval) > 1:\n",
    "                                mult = round(anchor/interval)\n",
    "                            else:\n",
    "                                mult = 1\n",
    "                    else:\n",
    "                        mult = mult\n",
    "                    mult = 1\n",
    "                    for i in range(len(df)):\n",
    "                        emaF1 = df.loc[i,'ema_3']\n",
    "                        emaF2 = df.loc[i,'ema_5']\n",
    "                        emaF3 = df.loc[i,'ema_7']\n",
    "                        emaF4 = df.loc[i,'ema_9']\n",
    "                        emaF5 = df.loc[i,'ema_11']\n",
    "                        emaF6 = df.loc[i,'ema_13']\n",
    "                        emaF7 = df.loc[i,'ema_15']\n",
    "                        emaF8 = df.loc[i,'ema_17']\n",
    "                        emaF9 = df.loc[i,'ema_19']\n",
    "                        emaF10 = df.loc[i,'ema_21']\n",
    "                        emaF11 = df.loc[i,'ema_23']\n",
    "                        emaS1 = df.loc[i,'ema_25']\n",
    "                        emaS2 = df.loc[i,'ema_28']\n",
    "                        emaS3 = df.loc[i,'ema_31']\n",
    "                        emaS4 = df.loc[i,'ema_34']\n",
    "                        emaS5 = df.loc[i,'ema_37']\n",
    "                        emaS6 = df.loc[i,'ema_40']\n",
    "                        emaS7 = df.loc[i,'ema_43']\n",
    "                        emaS8 = df.loc[i,'ema_46']\n",
    "                        emaS9 = df.loc[i,'ema_49']\n",
    "                        emaS10 = df.loc[i,'ema_52']\n",
    "                        emaS11 = df.loc[i,'ema_55']\n",
    "                        emaS12 = df.loc[i,'ema_58']\n",
    "                        emaS13 = df.loc[i,'ema_61']\n",
    "                        emaS14 = df.loc[i,'ema_64']\n",
    "                        emaS15 = df.loc[i,'ema_67']\n",
    "                        emaS16 = df.loc[i,'ema_70']\n",
    "                        ema200 = df.loc[i,'ema_200'] \n",
    "                        emafast = (emaF1 + emaF2 + emaF3 + emaF4 + emaF5 + emaF6 + emaF7 + emaF8 + emaF9 + emaF10 + emaF11)/11\n",
    "                        emaslow = (emaS1 + emaS2 + emaS3 + emaS4 + emaS5 + emaS6 + emaS7 + emaS8 + emaS9 + emaS10 + emaS11 + emaS12 + emaS13 + emaS14 + emaS15 + emaS16)/16\n",
    "                        #Fast EMA Color Rules\n",
    "                        colfastL = (emaF1>emaF2 and emaF2>emaF3 and emaF3>emaF4 and emaF4>emaF5 and emaF5>emaF6 and emaF6>emaF7 and emaF7>emaF8 and emaF8>emaF9 and emaF9>emaF10 and emaF10>emaF11)\n",
    "                        colfastS = (emaF1<emaF2 and emaF2<emaF3 and emaF3<emaF4 and emaF4<emaF5 and emaF5<emaF6 and emaF6<emaF7 and emaF7<emaF8 and emaF8<emaF9 and emaF9<emaF10 and emaF10<emaF11)\n",
    "                        #Slow EMA Color Rules\n",
    "                        colslowL = (emaS1>emaS2 and emaS2>emaS3 and emaS3>emaS4 and emaS4>emaS5 and emaS5>emaS6 and emaS6>emaS7 and emaS7>emaS8) and (emaS8>emaS9 and emaS9>emaS10 and emaS10>emaS11 and emaS11>emaS12 and emaS12>emaS13 and emaS13>emaS14 and emaS14>emaS15 and emaS15>emaS16)\n",
    "                        colslowS = (emaS1<emaS2 and emaS2<emaS3 and emaS3<emaS4 and emaS4<emaS5 and emaS5<emaS6 and emaS6<emaS7 and emaS7<emaS8) and (emaS8<emaS9 and emaS9<emaS10 and emaS10<emaS11 and emaS11<emaS12 and emaS12<emaS13 and emaS13<emaS14 and emaS14<emaS15 and emaS15<emaS16)\n",
    "                        if  emafast > emaslow and not colslowS and colfastL and (not ShowCon or colslowL) and (not emaFilter or emafast>ema200):\n",
    "                            if int(buy1[-1]) > 0:\n",
    "                                buy = buy1[-1] + 1\n",
    "                            else:\n",
    "                                buy = 1\n",
    "                        else:\n",
    "                            buy = 0\n",
    "                        buy1.append(buy)\n",
    "                        if  emafast < emaslow and not colslowL and colfastS and (not ShowCon or colslowS) and (not emaFilter or emafast<ema200):\n",
    "                            if int(sell1[-1]) > 0:\n",
    "                                sell = sell1[-1] + 1\n",
    "                            else:\n",
    "                                sell = 1\n",
    "                        else:\n",
    "                            sell = 0\n",
    "                        sell1.append(sell)\n",
    "                        #buy\n",
    "                        if buy>1 and colfastL and (uOCCswing and ((df.loc[i-1,'close']<df.loc[i-1,'open']) and (df.loc[i,'close']>df.loc[i,'open']))):\n",
    "                            buy3 = 1\n",
    "                        else:\n",
    "                            buy3 = buy\n",
    "                        buy2.append(buy3)\n",
    "                        #sell    \n",
    "                        if sell>1 and colfastS and (uOCCswing and ((df.loc[i-1,'close']<df.loc[i-1,'open']) and (df.loc[i,'close']>df.loc[i,'open']))):\n",
    "                            sell3 = 1\n",
    "                        else:\n",
    "                            sell3 = sell\n",
    "                        sell2.append(sell3)\n",
    "                        #buybreak\n",
    "                        if emafast > emaslow and not colslowS and (not emaFilter or emafast>ema200):\n",
    "                            if buybreak1[-1] > 0:\n",
    "                                buybreak = buybreak1[-1] + 1\n",
    "                            else:\n",
    "                                buybreak = 1\n",
    "                        else:\n",
    "                            buybreak = 0\n",
    "                        buybreak1.append(buybreak)\n",
    "                        if emafast < emaslow and not colslowL and (not emaFilter or emafast<ema200):\n",
    "                            if sellbreak1[-1] > 0:\n",
    "                                sellbreak = sellbreak1[-1]+1\n",
    "                            else:\n",
    "                                sellbreak = 1\n",
    "                        else:\n",
    "                            sellbreak = 0\n",
    "                        sellbreak1.append(sellbreak)\n",
    "                        #arrow plotting\n",
    "                        #buy_arrow\n",
    "                        buy_barssince_var = barssince(buy2[:-1],barssince_var)\n",
    "                        if (ShowSwing and buy3==1)and buy_barssince_var > 6:\n",
    "                            buy_arrow = 1\n",
    "                        else:\n",
    "                            buy_arrow = 0\n",
    "                        #sell arrow\n",
    "                        sell_barssince_var = barssince(sell2[:-1],barssince_var)\n",
    "                        if ShowSwing and (sell3==1 and sell_barssince_var > 6):\n",
    "                            sell_arrow = 1\n",
    "                        else:\n",
    "                            sell_arrow = 0\n",
    "                        #buybreak_arrow\n",
    "                        buybreak_barssince_var = barssince(buybreak1[:-1],barssince_var)\n",
    "                        sellbreak_barssince_var = barssince(sellbreak1[:-1],barssince_var)\n",
    "\n",
    "                        if ShowBreak and buybreak==1 and (sellbreak_barssince_var>Lookback) and (buybreak_barssince_var>Lookback):\n",
    "                            buybreak_arrow = 1\n",
    "                        else:\n",
    "                            buybreak_arrow = 0\n",
    "                        #sellbreak_arrow\n",
    "                        if ShowBreak and sellbreak==1 and (buybreak_barssince_var>Lookback) and (sellbreak_barssince_var>Lookback):\n",
    "                            sellbreak_arrow = 1\n",
    "                        else:\n",
    "                            sellbreak_arrow = 0\n",
    "                        if buy_arrow==1 and sell_arrow==0 and buybreak_arrow==0 and sellbreak_arrow==0:\n",
    "                            arrow_color = 'green'\n",
    "                        elif buy_arrow==0 and sell_arrow==1 and buybreak_arrow==0 and sellbreak_arrow==0:\n",
    "                            arrow_color = 'red'\n",
    "                        elif sell_arrow==0 and (buy_arrow==0 or buy_arrow==1) and buybreak_arrow==1 and sellbreak_arrow==0:\n",
    "                            arrow_color = 'aqua'\n",
    "                        elif buy_arrow==0 and (sell_arrow==1 or sell_arrow==0) and buybreak_arrow==0 and sellbreak_arrow==1:\n",
    "                            arrow_color = 'blue'\n",
    "                        else:\n",
    "                            arrow_color = 'none'\n",
    "                        df.loc[i,'arrow_color'] = arrow_color\n",
    "                    df = df[['date','open','high','low','close','arrow_color']]\n",
    "                    return df\n",
    "                df=super_guppy(15,df)\n",
    "                gup=df\n",
    "                print(\" \\t \\t \\t \\t Zerodha GUPPY SCREENER on 15 minute data \")\n",
    "                print(\"\\t \\t \\t \\n Current Token checking  \" , tokenall[a])\n",
    "                print(\"\\n\" )\n",
    "                print(\" \\t \\t \\t \\n Current Colour on this token is \" , gup.iloc[-1,5])\n",
    "                if \"green\" in gup.iloc[-1,5]: # \n",
    "                    print(\"Buy stock found \")\n",
    "                    buy10minute.append((tokenall[a]))\n",
    "                if \"red\" in gup.iloc[-1,5]:\n",
    "                    print(\" Sell Stock found \")\n",
    "                    sell10minute.append((tokenall[a]))\n",
    "                else:\n",
    "                    pass\n",
    "                print(\"Buy stock found for 15 minute are  :=\"  ,buy10minute)\n",
    "                print(\"Sell stocks found for 15 minute are:=\"  ,sell10minute)\n",
    "                a=a+1\n",
    "                if a==len(tokenall):\n",
    "                    file=str(buy5minute)\n",
    "                    filee=str(sell5minute)\n",
    "                    file2=str(buy10minute)\n",
    "                    filee2=str(sell10minute)\n",
    "                    with open(\"tokens.txt\",\"w\") as  f: # WRITIG ALL DATA TO FILE\n",
    "                        f.write(file)\n",
    "                        f.write(filee)\n",
    "                        f.write(file2)\n",
    "                        f.write(filee2)\n",
    "                    break\n",
    "\n",
    "    ashi15()\n",
    "    \n",
    "    # NOW SCANNING FOR 30 MINUTE TOKENS BUY/SELL\n",
    "    \n",
    "    print(\"5 and 15 minute data complete now getting Data of 30 minutes of minute frame\")\n",
    "    time_frame     =\"30minute\"\n",
    "    a=0\n",
    "    def ashi30():\n",
    "        global a\n",
    "        global BUY_listindicator\n",
    "        global SELL_listindicator\n",
    "        while(True):\n",
    "                print(\"\\n\" )\n",
    "                print(\"Current Token Number which is processing is\",a)\n",
    "            #km=datetime.now().minute\n",
    "            #ks=datetime.now().second\n",
    "            #if km%1==0 and ks==1:\n",
    "                clear_output(wait=True)  \n",
    "                now_utc = datetime.now(timezone('UTC'))\n",
    "                now_asia = now_utc.astimezone(timezone('Asia/Kolkata'))\n",
    "                now_asia = now_asia.strftime(\"%S \")\n",
    "                klp1=now_asia\n",
    "                #df=kite.historical_data(140033,sdate,todate,time_frame,0)\n",
    "                dff=kite.historical_data(tokenall[a],sdate,todate,time_frame,0)\n",
    "                dfw=pd.DataFrame(dff)\n",
    "                df=pd.DataFrame(dfw[['date','open','high','low','close']])\n",
    "                slow_ema = [3,5,7,9,11,13,15,17,19,21,23]\n",
    "                fast_ema = [25,28,31,34,37,40,43,46,49,52,55,58,61,64,67,70,200]\n",
    "                def EMA(df, base, target, period, alpha=False):\n",
    "                    con = pd.concat([df[:period][base].rolling(window=period).mean(), df[period:][base]])\n",
    "                    if (alpha == True):\n",
    "                        # (1 - alpha) * previous_val + alpha * current_val where alpha = 1 / period\n",
    "                        df[target] = con.ewm(alpha=1 / period, adjust=False).mean()\n",
    "                    else:\n",
    "                        # ((current_val - previous_val) * coeff) + previous_val where coeff = 2 / (period + 1)\n",
    "                        df[target] = con.ewm(span=period, adjust=False).mean()\n",
    "                    df.fillna(0,inplace = True)\n",
    "                #     return df\n",
    "                for j in slow_ema:\n",
    "                    val = \"ema\"+\"_\"+str(j)\n",
    "                    EMA(df,\"close\",val,j)\n",
    "                for k in fast_ema:\n",
    "                    val = \"ema\"+\"_\"+str(k)\n",
    "                    EMA(df,\"close\",val,k)\n",
    "                def super_guppy(interval,df,anchor=0):\n",
    "                #     df['buy'] = 0\n",
    "                #     df['sell'] = 0\n",
    "                #     df['buybreak'] = 0\n",
    "                #     df['sellbreak'] = 0\n",
    "                    anchor = 0\n",
    "                    ShowBreak = True\n",
    "                    ShowSwing = True\n",
    "                    ShowCon = False\n",
    "                    uOCCswing = False\n",
    "                    Lookback = 6\n",
    "                    emaFilter = False\n",
    "                    mult = 0\n",
    "                    buybreak = 0\n",
    "                    sellbreak = 0\n",
    "                    buy_barssince_var = 0\n",
    "                    sell_barssince_var = 0\n",
    "                    buybreak_barssince_var = 0\n",
    "                    sellbreak_barssince_var = 0\n",
    "                    barssince_lst = list()\n",
    "                    barssince_var = 0\n",
    "                    bar_count_var = 0\n",
    "                    buy1 = list()\n",
    "                    sell1 = list()\n",
    "                    buy2 = list()\n",
    "                    sell2 = list()\n",
    "                    buybreak1 = list()\n",
    "                    sellbreak1 = list()\n",
    "                    def barssince(b,barssince_var):\n",
    "                        barssince_lst = []\n",
    "                        barssince_var = 0 \n",
    "                        new_var = len(b)\n",
    "                        for i in b[::-1]:\n",
    "                            if i == 1:\n",
    "                                break\n",
    "                            barssince_lst.append(i)\n",
    "                        barssince_var = len(barssince_lst)\n",
    "                        return barssince_var\n",
    "                        barssince_lst.clear()\n",
    "                    #isIntraday\n",
    "                    if interval < 1441 :\n",
    "                        if (anchor==0 or interval <= 0 or interval >= anchor or anchor > 1441 ):\n",
    "                            mult = 1\n",
    "                        else:\n",
    "                            if round(anchor/interval) > 1:\n",
    "                                mult = round(anchor/interval)\n",
    "                            else:\n",
    "                                mult = 1\n",
    "                    else:\n",
    "                        mult = 1\n",
    "                    #isIntraday Not\n",
    "                    if interval > 1441:\n",
    "                        if (anchor==0 or interval <= 0 or interval >= anchor or anchor < 52 ):\n",
    "                            mult = mult\n",
    "                        else:\n",
    "                            if round(anchor/interval) > 1:\n",
    "                                mult = round(anchor/interval)\n",
    "                            else:\n",
    "                                mult = 1\n",
    "                    else:\n",
    "                        mult = mult\n",
    "                    mult = 1\n",
    "                    for i in range(len(df)):\n",
    "                        emaF1 = df.loc[i,'ema_3']\n",
    "                        emaF2 = df.loc[i,'ema_5']\n",
    "                        emaF3 = df.loc[i,'ema_7']\n",
    "                        emaF4 = df.loc[i,'ema_9']\n",
    "                        emaF5 = df.loc[i,'ema_11']\n",
    "                        emaF6 = df.loc[i,'ema_13']\n",
    "                        emaF7 = df.loc[i,'ema_15']\n",
    "                        emaF8 = df.loc[i,'ema_17']\n",
    "                        emaF9 = df.loc[i,'ema_19']\n",
    "                        emaF10 = df.loc[i,'ema_21']\n",
    "                        emaF11 = df.loc[i,'ema_23']\n",
    "                        emaS1 = df.loc[i,'ema_25']\n",
    "                        emaS2 = df.loc[i,'ema_28']\n",
    "                        emaS3 = df.loc[i,'ema_31']\n",
    "                        emaS4 = df.loc[i,'ema_34']\n",
    "                        emaS5 = df.loc[i,'ema_37']\n",
    "                        emaS6 = df.loc[i,'ema_40']\n",
    "                        emaS7 = df.loc[i,'ema_43']\n",
    "                        emaS8 = df.loc[i,'ema_46']\n",
    "                        emaS9 = df.loc[i,'ema_49']\n",
    "                        emaS10 = df.loc[i,'ema_52']\n",
    "                        emaS11 = df.loc[i,'ema_55']\n",
    "                        emaS12 = df.loc[i,'ema_58']\n",
    "                        emaS13 = df.loc[i,'ema_61']\n",
    "                        emaS14 = df.loc[i,'ema_64']\n",
    "                        emaS15 = df.loc[i,'ema_67']\n",
    "                        emaS16 = df.loc[i,'ema_70']\n",
    "                        ema200 = df.loc[i,'ema_200'] \n",
    "                        emafast = (emaF1 + emaF2 + emaF3 + emaF4 + emaF5 + emaF6 + emaF7 + emaF8 + emaF9 + emaF10 + emaF11)/11\n",
    "                        emaslow = (emaS1 + emaS2 + emaS3 + emaS4 + emaS5 + emaS6 + emaS7 + emaS8 + emaS9 + emaS10 + emaS11 + emaS12 + emaS13 + emaS14 + emaS15 + emaS16)/16\n",
    "                        #Fast EMA Color Rules\n",
    "                        colfastL = (emaF1>emaF2 and emaF2>emaF3 and emaF3>emaF4 and emaF4>emaF5 and emaF5>emaF6 and emaF6>emaF7 and emaF7>emaF8 and emaF8>emaF9 and emaF9>emaF10 and emaF10>emaF11)\n",
    "                        colfastS = (emaF1<emaF2 and emaF2<emaF3 and emaF3<emaF4 and emaF4<emaF5 and emaF5<emaF6 and emaF6<emaF7 and emaF7<emaF8 and emaF8<emaF9 and emaF9<emaF10 and emaF10<emaF11)\n",
    "                        #Slow EMA Color Rules\n",
    "                        colslowL = (emaS1>emaS2 and emaS2>emaS3 and emaS3>emaS4 and emaS4>emaS5 and emaS5>emaS6 and emaS6>emaS7 and emaS7>emaS8) and (emaS8>emaS9 and emaS9>emaS10 and emaS10>emaS11 and emaS11>emaS12 and emaS12>emaS13 and emaS13>emaS14 and emaS14>emaS15 and emaS15>emaS16)\n",
    "                        colslowS = (emaS1<emaS2 and emaS2<emaS3 and emaS3<emaS4 and emaS4<emaS5 and emaS5<emaS6 and emaS6<emaS7 and emaS7<emaS8) and (emaS8<emaS9 and emaS9<emaS10 and emaS10<emaS11 and emaS11<emaS12 and emaS12<emaS13 and emaS13<emaS14 and emaS14<emaS15 and emaS15<emaS16)\n",
    "                        if  emafast > emaslow and not colslowS and colfastL and (not ShowCon or colslowL) and (not emaFilter or emafast>ema200):\n",
    "                            if int(buy1[-1]) > 0:\n",
    "                                buy = buy1[-1] + 1\n",
    "                            else:\n",
    "                                buy = 1\n",
    "                        else:\n",
    "                            buy = 0\n",
    "                        buy1.append(buy)\n",
    "                        if  emafast < emaslow and not colslowL and colfastS and (not ShowCon or colslowS) and (not emaFilter or emafast<ema200):\n",
    "                            if int(sell1[-1]) > 0:\n",
    "                                sell = sell1[-1] + 1\n",
    "                            else:\n",
    "                                sell = 1\n",
    "                        else:\n",
    "                            sell = 0\n",
    "                        sell1.append(sell)\n",
    "                        #buy\n",
    "                        if buy>1 and colfastL and (uOCCswing and ((df.loc[i-1,'close']<df.loc[i-1,'open']) and (df.loc[i,'close']>df.loc[i,'open']))):\n",
    "                            buy3 = 1\n",
    "                        else:\n",
    "                            buy3 = buy\n",
    "                        buy2.append(buy3)\n",
    "                        #sell    \n",
    "                        if sell>1 and colfastS and (uOCCswing and ((df.loc[i-1,'close']<df.loc[i-1,'open']) and (df.loc[i,'close']>df.loc[i,'open']))):\n",
    "                            sell3 = 1\n",
    "                        else:\n",
    "                            sell3 = sell\n",
    "                        sell2.append(sell3)\n",
    "                        #buybreak\n",
    "                        if emafast > emaslow and not colslowS and (not emaFilter or emafast>ema200):\n",
    "                            if buybreak1[-1] > 0:\n",
    "                                buybreak = buybreak1[-1] + 1\n",
    "                            else:\n",
    "                                buybreak = 1\n",
    "                        else:\n",
    "                            buybreak = 0\n",
    "                        buybreak1.append(buybreak)\n",
    "                        if emafast < emaslow and not colslowL and (not emaFilter or emafast<ema200):\n",
    "                            if sellbreak1[-1] > 0:\n",
    "                                sellbreak = sellbreak1[-1]+1\n",
    "                            else:\n",
    "                                sellbreak = 1\n",
    "                        else:\n",
    "                            sellbreak = 0\n",
    "                        sellbreak1.append(sellbreak)\n",
    "                        #arrow plotting\n",
    "                        #buy_arrow\n",
    "                        buy_barssince_var = barssince(buy2[:-1],barssince_var)\n",
    "                        if (ShowSwing and buy3==1)and buy_barssince_var > 6:\n",
    "                            buy_arrow = 1\n",
    "                        else:\n",
    "                            buy_arrow = 0\n",
    "                        #sell arrow\n",
    "                        sell_barssince_var = barssince(sell2[:-1],barssince_var)\n",
    "                        if ShowSwing and (sell3==1 and sell_barssince_var > 6):\n",
    "                            sell_arrow = 1\n",
    "                        else:\n",
    "                            sell_arrow = 0\n",
    "                        #buybreak_arrow\n",
    "                        buybreak_barssince_var = barssince(buybreak1[:-1],barssince_var)\n",
    "                        sellbreak_barssince_var = barssince(sellbreak1[:-1],barssince_var)\n",
    "\n",
    "                        if ShowBreak and buybreak==1 and (sellbreak_barssince_var>Lookback) and (buybreak_barssince_var>Lookback):\n",
    "                            buybreak_arrow = 1\n",
    "                        else:\n",
    "                            buybreak_arrow = 0\n",
    "                        #sellbreak_arrow\n",
    "                        if ShowBreak and sellbreak==1 and (buybreak_barssince_var>Lookback) and (sellbreak_barssince_var>Lookback):\n",
    "                            sellbreak_arrow = 1\n",
    "                        else:\n",
    "                            sellbreak_arrow = 0\n",
    "                        if buy_arrow==1 and sell_arrow==0 and buybreak_arrow==0 and sellbreak_arrow==0:\n",
    "                            arrow_color = 'green'\n",
    "                        elif buy_arrow==0 and sell_arrow==1 and buybreak_arrow==0 and sellbreak_arrow==0:\n",
    "                            arrow_color = 'red'\n",
    "                        elif sell_arrow==0 and (buy_arrow==0 or buy_arrow==1) and buybreak_arrow==1 and sellbreak_arrow==0:\n",
    "                            arrow_color = 'aqua'\n",
    "                        elif buy_arrow==0 and (sell_arrow==1 or sell_arrow==0) and buybreak_arrow==0 and sellbreak_arrow==1:\n",
    "                            arrow_color = 'blue'\n",
    "                        else:\n",
    "                            arrow_color = 'none'\n",
    "                        df.loc[i,'arrow_color'] = arrow_color\n",
    "                    df = df[['date','open','high','low','close','arrow_color']]\n",
    "                    return df\n",
    "                df=super_guppy(15,df)\n",
    "                gup=df\n",
    "                print(\" \\t \\t \\t \\t Zerodha GUPPY SCREENER for 30 minute Data\")\n",
    "                print(\"\\n\" )\n",
    "                print(\"\\t \\t \\t \\n Current Token checking  \" , tokenall[a])\n",
    "                print(\"\\n\" )\n",
    "                print(\" \\t \\t \\t \\n Current Colour on this token is \" , gup.iloc[-1,5])\n",
    "                if \"green\" in gup.iloc[-1,5]:\n",
    "                    print(\"BUY stock found \")\n",
    "                    buy15minute.append((tokenall[a]))\n",
    "                if \"red\" in gup.iloc[-1,5]:\n",
    "                    print(\" SELL Stock found \")\n",
    "                    sell15minute.append((tokenall[a]))\n",
    "                else:\n",
    "                    pass\n",
    "                print(\"Buy stock found for 30 minute are  :=\"  ,buy15minute)\n",
    "                print(\"Sell stocks found for 30 minute are:=\"  ,sell15minute)\n",
    "                a=a+1\n",
    "                if a==len(tokenall):\n",
    "                    file=str(buy5minute)\n",
    "                    filee=str(sell5minute)\n",
    "                    file2=str(buy10minute)\n",
    "                    filee2=str(sell10minute)\n",
    "                    file3=str(buy15minute)\n",
    "                    filee3=str(sell15minute)\n",
    "                    with open(\"tokens\",\"w\") as  f:\n",
    "                        f.write(file)\n",
    "                        f.write(filee)\n",
    "                        f.write(file2)\n",
    "                        f.write(filee2)\n",
    "                        f.write(file3)\n",
    "                        f.write(filee3)\n",
    "                        print(\"SCANNING COMPLETE\")\n",
    "                    break\n",
    "    ashi30()\n",
    "    \n",
    "    # SHOWING RESULTS FOR ALL THREE SCANNING\n",
    "    \n",
    "    print(\"5 ,15 and 30 are completed ! Results are \")\n",
    "    print(\"\\n\" )\n",
    "    print(\"tokens we get on 5 minute BUY  \"  ,buy5minute)\n",
    "    print(\"tokens we get on 5 minute SELL \" ,sell5minute)\n",
    "    print(\"\\n\" )\n",
    "    print(\"tokens we get on 15 minute BUY  \"  ,buy10minute)\n",
    "    print(\"tokens we get on 15 minute SELL \" ,sell10minute)\n",
    "    print(\"\\n\" )\n",
    "    print(\"tokens we get on 30 minute BUY  \" ,buy15minute)\n",
    "    print(\"tokens we get on 30 minute SELL \",sell15minute)\n",
    "    print(\"\\n\")\n",
    "    \n",
    "    k=set(buy5minute)\n",
    "    n=set(sell5minute)\n",
    "    l=set(buy10minute)\n",
    "    s=set(sell10minute)\n",
    "    m=set(buy15minute)\n",
    "    p=set(sell15minute)\n",
    "    buya=n|s|p\n",
    "    sellb=k|l|m\n",
    "    \n",
    "    print(\"\\n\")\n",
    "    print(\"BUY from ALL  \",sellb)\n",
    "    print(\"SELL From ALL \",buya)\n",
    "    print(\"\\n\")\n",
    "    print(\"  \\t \\t \\t \\t \\tBUY | SELL on 5 MINUTE\")\n",
    "    print(\"BUY\")\n",
    "    ee=0\n",
    "    buy_5minute=[]\n",
    "    sell_5minute=[]\n",
    "    buy_15minute=[]\n",
    "    sell_15minute=[]\n",
    "    buy_30minute=[]\n",
    "    sell_30minute=[]\n",
    "    ########################\n",
    "    if buy5minute:\n",
    "        while (True):\n",
    "            df=pd.DataFrame(kite.instruments(\"NSE\"))[[\"instrument_token\",\"tradingsymbol\",\"name\"]]\n",
    "            zall=df[df[\"instrument_token\"]==buy5minute[ee]]\n",
    "            buy_5minute.append(zall.iloc[-1,1])\n",
    "            ee=ee+1\n",
    "            if ee==len(buy5minute):\n",
    "                break\n",
    "    print(buy_5minute)\n",
    "    print(\"SELL\")\n",
    "    ee=0\n",
    "    if sell5minute:\n",
    "        while (True):\n",
    "            df=pd.DataFrame(kite.instruments(\"NSE\"))[[\"instrument_token\",\"tradingsymbol\",\"name\"]]\n",
    "            zall=df[df[\"instrument_token\"]==sell5minute[ee]]\n",
    "            sell_5minute.append(zall.iloc[-1,1])\n",
    "            ee=ee+1\n",
    "            if ee==len(sell5minute):\n",
    "                break\n",
    "    print(sell_5minute)\n",
    "    ###############################\n",
    "    print(\"\\n\")\n",
    "    print(\" \\t \\t \\t \\t \\t BUY | SELl on 15 minute\")\n",
    "    print(\"BUY\")\n",
    "    ee=0\n",
    "    if buy10minute:\n",
    "        while (True):\n",
    "            df=pd.DataFrame(kite.instruments(\"NSE\"))[[\"instrument_token\",\"tradingsymbol\",\"name\"]]\n",
    "            zall=df[df[\"instrument_token\"]==buy10minute[ee]]\n",
    "            buy_15minute.append(zall.iloc[-1,1])\n",
    "            ee=ee+1\n",
    "            if ee==len(buy10minute):\n",
    "                break\n",
    "    print(buy_15minute)\n",
    "    print(\"SELL\")\n",
    "    ee=0\n",
    "    if sell5minute:\n",
    "        while (True):\n",
    "            df=pd.DataFrame(kite.instruments(\"NSE\"))[[\"instrument_token\",\"tradingsymbol\",\"name\"]]\n",
    "            zall=df[df[\"instrument_token\"]==sell5minute[ee]]\n",
    "            sell_15minute.append(zall.iloc[-1,1])\n",
    "            ee=ee+1\n",
    "            if ee==len(sell5minute):\n",
    "                break\n",
    "    print(sell_15minute)\n",
    "    ####################################\n",
    "    print(\"\\n\")\n",
    "    print(\" \\t \\t \\t \\t \\t BUY | SELl on 30 minute\")\n",
    "    print(\"BUY\")\n",
    "    ee=0\n",
    "    if buy15minute:\n",
    "        while (True):\n",
    "            df=pd.DataFrame(kite.instruments(\"NSE\"))[[\"instrument_token\",\"tradingsymbol\",\"name\"]]\n",
    "            zall=df[df[\"instrument_token\"]==buy15minute[ee]]\n",
    "            buy_30minute.append(zall.iloc[-1,1])\n",
    "            ee=ee+1\n",
    "            if ee==len(buy15minute):\n",
    "                break\n",
    "    print(buy_30minute)\n",
    "    print(\"SELL\")\n",
    "    ee=0\n",
    "    if sell15minute:\n",
    "        while (True):\n",
    "            df=pd.DataFrame(kite.instruments(\"NSE\"))[[\"instrument_token\",\"tradingsymbol\",\"name\"]]\n",
    "            zall=df[df[\"instrument_token\"]==sell15minute[ee]]\n",
    "            buy_30minute.append(zall.iloc[-1,1])\n",
    "            ee=ee+1\n",
    "            if ee==len(sell15minute):\n",
    "                break\n",
    "    print(sell_30minute)\n",
    "    print(\" \\n \")\n",
    "    print(\" \\t \\t \\t \\t \\t OVERALL BUY  SELL \")\n",
    "    print(\" \\n \")\n",
    "    print(\" OVERALL -  BUY \", buy_5minute,buy_15minute,buy_30minute)\n",
    "    print(\" OVERALL - SELL\" , sell_5minute,sell_15minute,sell_30minute)\n",
    "    print(\" \\n \")\n",
    "    print(\" \\t \\t \\t \\t \\t COMMON BUY-SELL After filter \")\n",
    "    abuy=list(buya)\n",
    "    buy_set=[]\n",
    "    ee=0\n",
    "    if sell15minute:\n",
    "        while (True):\n",
    "            df=pd.DataFrame(kite.instruments(\"NSE\"))[[\"instrument_token\",\"tradingsymbol\",\"name\"]]\n",
    "            zall=df[df[\"instrument_token\"]==abuy[ee]]\n",
    "            buy_set.append(zall.iloc[-1,1])\n",
    "            ee=ee+1\n",
    "            if ee==len(abuy):\n",
    "                break\n",
    "    asell=list(sellb)\n",
    "    sell_set=[]\n",
    "    ee=0\n",
    "    if asell:\n",
    "        while (True):\n",
    "            df=pd.DataFrame(kite.instruments(\"NSE\"))[[\"instrument_token\",\"tradingsymbol\",\"name\"]]\n",
    "            zall=df[df[\"instrument_token\"]==asell[ee]]\n",
    "            sell_set.append(zall.iloc[-1,1])\n",
    "            ee=ee+1\n",
    "            if ee==len(asell):\n",
    "                break\n",
    "    print(\" OVERALL BUY\" ,buy_set)\n",
    "    print(\" OVERALL SELL\",sell_set)\n",
    "    print(\"\\t \\t \\t \\t \\t !! ALL COMPLETED !!\")\n",
    "    print(\" \\n \")\n",
    "    ############################################\n",
    "    print(\"WELCOME TO GUPPY BOT ! ENTER 'BUY' or 'SELL', which you want\")\n",
    "    user=str(input(\" ENTER BUY or SELL :-\"))\n",
    "    print(\" ** ENTER ALL DETAILS IN CAPITAL LETTERS ONLY **\")\n",
    "    ttradingsymbol =str(input(\"ENTER TRADINGSYMBOL - SUNPHARMA / SBIN :-\"))\n",
    "    eexchange      =str(input(\"ENTER EXCHANGE / NSE / BSE / CDS  :-\"))\n",
    "    productt       =str(input(\"ENTER PRODUCT / NRML /CNC / MIS  :-\"))\n",
    "    qu             =int(input(\"ENTER QUANTITY - 2 / 4 :-\")) \n",
    "    time_frame     =str(input(\"ENTER TIME_FRAME - minute / 5minute **SMALL letters only** :-\"))\n",
    "    sdate          =\"2019-06-05\"\n",
    "    todate         =\"2020-10-02\"\n",
    "    buy_add=.50\n",
    "    sell_add=.50\n",
    "    ttoken=int(pd.DataFrame(kite.ltp(eexchange+\":\"+ttradingsymbol)).iloc[-2,0])\n",
    "    ###\n",
    "    if \"SELL\"==user or \"sell\"==user:\n",
    "        print(\" SELL BOT STARTED After Scanning ! \")\n",
    "        counter_start=[0]\n",
    "        linkedlist_1=[]       \n",
    "        linkedlist_2=[]      \n",
    "        linkedlist_3=[]      \n",
    "        counter=[0,10]      \n",
    "        checkfirst=[0]      \n",
    "        redb=[]             \n",
    "        bluez=[]            \n",
    "        aqua1=[0]           \n",
    "        bluein=[]           \n",
    "        blue_2F=[]          \n",
    "        blue_2G=[]          \n",
    "        count_sectime=[]\n",
    "        redc=[]\n",
    "        colourstill=[]\n",
    "        prog_starts=[]\n",
    "        #Variables\n",
    "        lst_candle=[]\n",
    "        lst_heikin_nor=[]\n",
    "        lst_heikin=[]\n",
    "        lst_cand=[]\n",
    "        lst_c=[]\n",
    "        countstart=0\n",
    "        #programe start\n",
    "        def ashis():\n",
    "            while(True):\n",
    "                km=datetime.now().minute\n",
    "                ks=datetime.now().second\n",
    "                if km%1==0 and ks==1:\n",
    "                    clear_output(wait=True)  \n",
    "                    now_utc = datetime.now(timezone('UTC'))\n",
    "                    now_asia = now_utc.astimezone(timezone('Asia/Kolkata'))\n",
    "                    now_asia = now_asia.strftime(\"%S \")\n",
    "                    klp1=now_asia\n",
    "                    #df=kite.historical_data(140033,sdate,todate,time_frame,0)\n",
    "                    dff=kite.historical_data(ttoken,sdate,todate,time_frame,0)\n",
    "                    dfw=pd.DataFrame(dff)\n",
    "                    df=pd.DataFrame(dfw[['date','open','high','low','close']])\n",
    "                    slow_ema = [3,5,7,9,11,13,15,17,19,21,23]\n",
    "                    fast_ema = [25,28,31,34,37,40,43,46,49,52,55,58,61,64,67,70,200]\n",
    "                    def EMA(df, base, target, period, alpha=False):\n",
    "                        con = pd.concat([df[:period][base].rolling(window=period).mean(), df[period:][base]])\n",
    "                        if (alpha == True):\n",
    "                            # (1 - alpha) * previous_val + alpha * current_val where alpha = 1 / period\n",
    "                            df[target] = con.ewm(alpha=1 / period, adjust=False).mean()\n",
    "                        else:\n",
    "                            # ((current_val - previous_val) * coeff) + previous_val where coeff = 2 / (period + 1)\n",
    "                            df[target] = con.ewm(span=period, adjust=False).mean()\n",
    "                        df.fillna(0,inplace = True)\n",
    "                    #     return df\n",
    "                    for j in slow_ema:\n",
    "                        val = \"ema\"+\"_\"+str(j)\n",
    "                        EMA(df,\"close\",val,j)\n",
    "                    for k in fast_ema:\n",
    "                        val = \"ema\"+\"_\"+str(k)\n",
    "                        EMA(df,\"close\",val,k)\n",
    "                    def super_guppy(interval,df,anchor=0):\n",
    "                    #     df['buy'] = 0\n",
    "                    #     df['sell'] = 0\n",
    "                    #     df['buybreak'] = 0\n",
    "                    #     df['sellbreak'] = 0\n",
    "                        anchor = 0\n",
    "                        ShowBreak = True\n",
    "                        ShowSwing = True\n",
    "                        ShowCon = False\n",
    "                        uOCCswing = False\n",
    "                        Lookback = 6\n",
    "                        emaFilter = False\n",
    "                        mult = 0\n",
    "                        buybreak = 0\n",
    "                        sellbreak = 0\n",
    "                        buy_barssince_var = 0\n",
    "                        sell_barssince_var = 0\n",
    "                        buybreak_barssince_var = 0\n",
    "                        sellbreak_barssince_var = 0\n",
    "                        barssince_lst = list()\n",
    "                        barssince_var = 0\n",
    "                        bar_count_var = 0\n",
    "                        buy1 = list()\n",
    "                        sell1 = list()\n",
    "                        buy2 = list()\n",
    "                        sell2 = list()\n",
    "                        buybreak1 = list()\n",
    "                        sellbreak1 = list()\n",
    "                        def barssince(b,barssince_var):\n",
    "                            barssince_lst = []\n",
    "                            barssince_var = 0 \n",
    "                            new_var = len(b)\n",
    "                            for i in b[::-1]:\n",
    "                                if i == 1:\n",
    "                                    break\n",
    "                                barssince_lst.append(i)\n",
    "                            barssince_var = len(barssince_lst)\n",
    "                            return barssince_var\n",
    "                            barssince_lst.clear()\n",
    "                        #isIntraday\n",
    "                        if interval < 1441 :\n",
    "                            if (anchor==0 or interval <= 0 or interval >= anchor or anchor > 1441 ):\n",
    "                                mult = 1\n",
    "                            else:\n",
    "                                if round(anchor/interval) > 1:\n",
    "                                    mult = round(anchor/interval)\n",
    "                                else:\n",
    "                                    mult = 1\n",
    "                        else:\n",
    "                            mult = 1\n",
    "                        #isIntraday Not\n",
    "                        if interval > 1441:\n",
    "                            if (anchor==0 or interval <= 0 or interval >= anchor or anchor < 52 ):\n",
    "                                mult = mult\n",
    "                            else:\n",
    "                                if round(anchor/interval) > 1:\n",
    "                                    mult = round(anchor/interval)\n",
    "                                else:\n",
    "                                    mult = 1\n",
    "                        else:\n",
    "                            mult = mult\n",
    "                        mult = 1\n",
    "                        for i in range(len(df)):\n",
    "                            emaF1 = df.loc[i,'ema_3']\n",
    "                            emaF2 = df.loc[i,'ema_5']\n",
    "                            emaF3 = df.loc[i,'ema_7']\n",
    "                            emaF4 = df.loc[i,'ema_9']\n",
    "                            emaF5 = df.loc[i,'ema_11']\n",
    "                            emaF6 = df.loc[i,'ema_13']\n",
    "                            emaF7 = df.loc[i,'ema_15']\n",
    "                            emaF8 = df.loc[i,'ema_17']\n",
    "                            emaF9 = df.loc[i,'ema_19']\n",
    "                            emaF10 = df.loc[i,'ema_21']\n",
    "                            emaF11 = df.loc[i,'ema_23']\n",
    "                            emaS1 = df.loc[i,'ema_25']\n",
    "                            emaS2 = df.loc[i,'ema_28']\n",
    "                            emaS3 = df.loc[i,'ema_31']\n",
    "                            emaS4 = df.loc[i,'ema_34']\n",
    "                            emaS5 = df.loc[i,'ema_37']\n",
    "                            emaS6 = df.loc[i,'ema_40']\n",
    "                            emaS7 = df.loc[i,'ema_43']\n",
    "                            emaS8 = df.loc[i,'ema_46']\n",
    "                            emaS9 = df.loc[i,'ema_49']\n",
    "                            emaS10 = df.loc[i,'ema_52']\n",
    "                            emaS11 = df.loc[i,'ema_55']\n",
    "                            emaS12 = df.loc[i,'ema_58']\n",
    "                            emaS13 = df.loc[i,'ema_61']\n",
    "                            emaS14 = df.loc[i,'ema_64']\n",
    "                            emaS15 = df.loc[i,'ema_67']\n",
    "                            emaS16 = df.loc[i,'ema_70']\n",
    "                            ema200 = df.loc[i,'ema_200'] \n",
    "                            emafast = (emaF1 + emaF2 + emaF3 + emaF4 + emaF5 + emaF6 + emaF7 + emaF8 + emaF9 + emaF10 + emaF11)/11\n",
    "                            emaslow = (emaS1 + emaS2 + emaS3 + emaS4 + emaS5 + emaS6 + emaS7 + emaS8 + emaS9 + emaS10 + emaS11 + emaS12 + emaS13 + emaS14 + emaS15 + emaS16)/16\n",
    "                            #Fast EMA Color Rules\n",
    "                            colfastL = (emaF1>emaF2 and emaF2>emaF3 and emaF3>emaF4 and emaF4>emaF5 and emaF5>emaF6 and emaF6>emaF7 and emaF7>emaF8 and emaF8>emaF9 and emaF9>emaF10 and emaF10>emaF11)\n",
    "                            colfastS = (emaF1<emaF2 and emaF2<emaF3 and emaF3<emaF4 and emaF4<emaF5 and emaF5<emaF6 and emaF6<emaF7 and emaF7<emaF8 and emaF8<emaF9 and emaF9<emaF10 and emaF10<emaF11)\n",
    "                            #Slow EMA Color Rules\n",
    "                            colslowL = (emaS1>emaS2 and emaS2>emaS3 and emaS3>emaS4 and emaS4>emaS5 and emaS5>emaS6 and emaS6>emaS7 and emaS7>emaS8) and (emaS8>emaS9 and emaS9>emaS10 and emaS10>emaS11 and emaS11>emaS12 and emaS12>emaS13 and emaS13>emaS14 and emaS14>emaS15 and emaS15>emaS16)\n",
    "                            colslowS = (emaS1<emaS2 and emaS2<emaS3 and emaS3<emaS4 and emaS4<emaS5 and emaS5<emaS6 and emaS6<emaS7 and emaS7<emaS8) and (emaS8<emaS9 and emaS9<emaS10 and emaS10<emaS11 and emaS11<emaS12 and emaS12<emaS13 and emaS13<emaS14 and emaS14<emaS15 and emaS15<emaS16)\n",
    "                            if  emafast > emaslow and not colslowS and colfastL and (not ShowCon or colslowL) and (not emaFilter or emafast>ema200):\n",
    "                                if int(buy1[-1]) > 0:\n",
    "                                    buy = buy1[-1] + 1\n",
    "                                else:\n",
    "                                    buy = 1\n",
    "                            else:\n",
    "                                buy = 0\n",
    "                            buy1.append(buy)\n",
    "                            if  emafast < emaslow and not colslowL and colfastS and (not ShowCon or colslowS) and (not emaFilter or emafast<ema200):\n",
    "                                if int(sell1[-1]) > 0:\n",
    "                                    sell = sell1[-1] + 1\n",
    "                                else:\n",
    "                                    sell = 1\n",
    "                            else:\n",
    "                                sell = 0\n",
    "                            sell1.append(sell)\n",
    "                            #buy\n",
    "                            if buy>1 and colfastL and (uOCCswing and ((df.loc[i-1,'close']<df.loc[i-1,'open']) and (df.loc[i,'close']>df.loc[i,'open']))):\n",
    "                                buy3 = 1\n",
    "                            else:\n",
    "                                buy3 = buy\n",
    "                            buy2.append(buy3)\n",
    "                            #sell    \n",
    "                            if sell>1 and colfastS and (uOCCswing and ((df.loc[i-1,'close']<df.loc[i-1,'open']) and (df.loc[i,'close']>df.loc[i,'open']))):\n",
    "                                sell3 = 1\n",
    "                            else:\n",
    "                                sell3 = sell\n",
    "                            sell2.append(sell3)\n",
    "                            #buybreak\n",
    "                            if emafast > emaslow and not colslowS and (not emaFilter or emafast>ema200):\n",
    "                                if buybreak1[-1] > 0:\n",
    "                                    buybreak = buybreak1[-1] + 1\n",
    "                                else:\n",
    "                                    buybreak = 1\n",
    "                            else:\n",
    "                                buybreak = 0\n",
    "                            buybreak1.append(buybreak)\n",
    "                            if emafast < emaslow and not colslowL and (not emaFilter or emafast<ema200):\n",
    "                                if sellbreak1[-1] > 0:\n",
    "                                    sellbreak = sellbreak1[-1]+1\n",
    "                                else:\n",
    "                                    sellbreak = 1\n",
    "                            else:\n",
    "                                sellbreak = 0\n",
    "                            sellbreak1.append(sellbreak)\n",
    "                            #arrow plotting\n",
    "                            #buy_arrow\n",
    "                            buy_barssince_var = barssince(buy2[:-1],barssince_var)\n",
    "                            if (ShowSwing and buy3==1)and buy_barssince_var > 6:\n",
    "                                buy_arrow = 1\n",
    "                            else:\n",
    "                                buy_arrow = 0\n",
    "                            #sell arrow\n",
    "                            sell_barssince_var = barssince(sell2[:-1],barssince_var)\n",
    "                            if ShowSwing and (sell3==1 and sell_barssince_var > 6):\n",
    "                                sell_arrow = 1\n",
    "                            else:\n",
    "                                sell_arrow = 0\n",
    "                            #buybreak_arrow\n",
    "                            buybreak_barssince_var = barssince(buybreak1[:-1],barssince_var)\n",
    "                            sellbreak_barssince_var = barssince(sellbreak1[:-1],barssince_var)\n",
    "\n",
    "                            if ShowBreak and buybreak==1 and (sellbreak_barssince_var>Lookback) and (buybreak_barssince_var>Lookback):\n",
    "                                buybreak_arrow = 1\n",
    "                            else:\n",
    "                                buybreak_arrow = 0\n",
    "                            #sellbreak_arrow\n",
    "                            if ShowBreak and sellbreak==1 and (buybreak_barssince_var>Lookback) and (sellbreak_barssince_var>Lookback):\n",
    "                                sellbreak_arrow = 1\n",
    "                            else:\n",
    "                                sellbreak_arrow = 0\n",
    "                            if buy_arrow==1 and sell_arrow==0 and buybreak_arrow==0 and sellbreak_arrow==0:\n",
    "                                arrow_color = 'green'\n",
    "                            elif buy_arrow==0 and sell_arrow==1 and buybreak_arrow==0 and sellbreak_arrow==0:\n",
    "                                arrow_color = 'red'\n",
    "                            elif sell_arrow==0 and (buy_arrow==0 or buy_arrow==1) and buybreak_arrow==1 and sellbreak_arrow==0:\n",
    "                                arrow_color = 'aqua'\n",
    "                            elif buy_arrow==0 and (sell_arrow==1 or sell_arrow==0) and buybreak_arrow==0 and sellbreak_arrow==1:\n",
    "                                arrow_color = 'blue'\n",
    "                            else:\n",
    "                                arrow_color = 'none'\n",
    "                            df.loc[i,'arrow_color'] = arrow_color\n",
    "                        df = df[['date','open','high','low','close','arrow_color']]\n",
    "                        return df\n",
    "                    df=super_guppy(15,df)\n",
    "                    gup=pd.DataFrame(df)\n",
    "                    def bidatrema(df,period):\n",
    "                        df['hl']=abs(df['high']-df['low'])\n",
    "                        df['hpc']=abs(df['high']-df['close'].shift())\n",
    "                        df['lpc']=abs(df['low']-df['close'].shift())\n",
    "                        df['tr']=df[['hl','hpc','lpc']].max(axis=1)\n",
    "                        df['ATR']=pd.DataFrame.ewm(df[\"tr\"], span=period,min_periods=period).mean()\n",
    "                        df.drop([\"hl\",\"hpc\",\"lpc\",\"tr\"],axis = 1 , inplace =True)\n",
    "                    bidatrema(gup,14)\n",
    "                    \n",
    "                    print(\" \\n \\t \\t \\t \\t  ZERODHA GUPPY BOT \")\n",
    "                    print(\" \\t \\t \\t \\n Current Colour on this token is \" , gup.iloc[-1,5])\n",
    "                    now_utc = datetime.now(timezone('UTC'))\n",
    "                    now_asia = now_utc.astimezone(timezone('Asia/Kolkata'))\n",
    "                    now_asia = now_asia.strftime(\"%Y-%m-%d _ %H:%M:%S \")\n",
    "                    klp1=now_asia\n",
    "                    prog_starts.append(klp1)\n",
    "                    print(\"\\n \")\n",
    "                    print(\"Zerodha GUPPY BOT start Time             \"  , prog_starts[0])\n",
    "                    print(\"\\n \")\n",
    "                    print(\"BOT working succeesfully on time:        \"  , now_asia )\n",
    "                    print(\"\\n \")\n",
    "                    print(\"Trading symbol is\",ttradingsymbol,\"Token is\",ttoken,\"Exchange is\",eexchange,\"and product type is\",productt,\"Quantity is\",qu,\"time frame for Historical Data is\",time_frame,\"Starting and Ending Date of Historical Data is\",sdate,todate)\n",
    "                    \n",
    "                    colourstill.append(gup.iloc[-1,5])\n",
    "                    print(\"\\n \")\n",
    "                    print(\"\\n \")\n",
    "                    if 0 in counter_start:\n",
    "                        if \"red\" in gup.iloc[-1,5]:\n",
    "                            counter_start.remove(0)\n",
    "                            counter_start.append(2)\n",
    "                        else:\n",
    "                            pass\n",
    "                    if 2 in counter_start:\n",
    "                        print(\" BOT STARTED WITH RED ' SELL' ENTRY \")\n",
    "                        if \"blank\" in gup.iloc[-1,5]:\n",
    "                            print(\" Nothing Done BUT BOT started no candel colour occur \")\n",
    "                        if \"red\" in gup.iloc[-1,5]:\n",
    "                            if 0 in counter:\n",
    "                                #SELl X amount                   #-------------------------------------------------------- (A)\n",
    "                                quant=qu\n",
    "                                stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                triggerprice_sell=stoploss_sell-sell_add\n",
    "                                #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"A\")\n",
    "                                kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"A\")\n",
    "                                print(\"red sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell, \"quantity is\",quant)\n",
    "                                linkedlist_1.insert(0,kite_drop)\n",
    "                                counter.remove(0)\n",
    "                                counter.append(1)\n",
    "                        if \"aqua\" in gup.iloc[-1,5]:\n",
    "                            if 1 in counter:\n",
    "                                if 10 in counter:\n",
    "                                    print(\"aqua Comes checking blue condition @ is previous green executed or not ?\") # (A)\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:   \n",
    "                                        print(\"ORDER COMPLETED and now buy x/2\" )\n",
    "                                        quant=int(qu/2)\n",
    "                                        cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                        lim_price=cur_high+buy_add\n",
    "                                        print(\"Congrats ! Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"Z\")\n",
    "                                        kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"Z\")\n",
    "                                        linkedlist_2.insert(0,kite_drop)\n",
    "                                        counter.remove(10) # -------------------------- ( Z )\n",
    "                                        bluez.append(0)\n",
    "                                    else:\n",
    "                                        print(\" sell not executed  \")\n",
    "                        if \"green\" in gup.iloc[-1,5]:\n",
    "                            if 1 in counter:                                              \n",
    "                                print(\"checking previous green executed or not \") \n",
    "                                update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                match_in_int=int(match_in)\n",
    "                                print(\"checking executed or not condition \")\n",
    "                                if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:   \n",
    "                                    print(\"ORDER COMPLETED and now BUY x/2\" )\n",
    "                                    quant=int(2*qu)\n",
    "                                    cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                    lim_price=cur_high+buy_add\n",
    "                                    print(\"Congrats ! No1 Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                    #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"B\")\n",
    "                                    kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"B\")\n",
    "                                    linkedlist_1.insert(0,kite_drop)\n",
    "                                    counter.remove(1)\n",
    "                                    counter.append(2)\n",
    "                                    redb.append(0)                                 # ------------------------ ( B )\n",
    "                                else:\n",
    "                                    print(\"aqua bid not complete now canceled aqua bid and place fresh BUY of x amount\")\n",
    "                                    bid_not_ex=int(linkedlist_1[0])\n",
    "                                    print(\"SL Cancel Order cancelled and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                    cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                    lim_price=cur_high+3 \n",
    "                                    print(\"Congrats ! Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                    #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"C\")\n",
    "                                    kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"C\")\n",
    "                                    linkedlist_3.insert(0,kite_drop)     #  ------------ -------------- ( C )\n",
    "                                    counter.remove(1)\n",
    "                                    counter.append(2) \n",
    "                                    redc.append(0)\n",
    "                                                    #       *********************** checking condition *********************\n",
    "                        if 0 in bluez:\n",
    "                            if 2 in counter:\n",
    "                                if 0 in checkfirst:\n",
    "                                    print(\" green placed and now checking RED executed or not condition \")\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        print(\" green executed \")\n",
    "                                        print(\" Now checkingaqua executed or not\")\n",
    "                                        update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                        match_in,=update_reverse[update_reverse.order_id==linkedlist_2[0]].index \n",
    "                                        match_in_int=int(match_in)\n",
    "                                        if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                            print(\" yes BLUE executed \")\n",
    "                                            print(\" BOTH aqua and green executed and now placig order qu/2 \")\n",
    "                                            quant=int(qu/2)\n",
    "                                            kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"BZ\")\n",
    "                                            print(\"Z and B both executed and market order placed\", \"quantity is\",quant)\n",
    "                                        else:\n",
    "                                            print(\"Z not executed \")\n",
    "                                            bid_not_ex=int(linkedlist_2[0])\n",
    "                                            print(\" aqua Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                    else:\n",
    "                                        pass\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                                                        #  *************** comming from back ****************  \n",
    "                        if 0 in count_sectime:\n",
    "                            if 2 in counnter:\n",
    "                                update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                match_in_int=int(match_in)\n",
    "                                print(\"checking executed or not condition \")\n",
    "                                if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_2[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu/2)\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"BZ\")\n",
    "                                        print(\"both executed and market order placed comming from back again\", \"quantity is\",quant)\n",
    "                                        count_sectime.remove(1)\n",
    "                                    else:\n",
    "                                        print(\"Z not executed \")\n",
    "                                        bid_not_ex=int(linkedlist_2[0])\n",
    "                                        print(\" aqua Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        count_sectime.remove(1)\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if \"blue\" in gup.iloc[-1,5]:\n",
    "                            if 2 in counter:\n",
    "                                if 0 in aqua1:\n",
    "                                    if 0 in redb:\n",
    "                                        update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                        match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                        match_in_int=int(match_in)\n",
    "                                        print(\"checking executed or not condition \")\n",
    "                                        if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                            # ( NOW SELL X/2 )         #------------------------------ ( D )\n",
    "                                            quant=int(qu/2)\n",
    "                                            stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                            triggerprice_sell=stoploss_sell-sell_add\n",
    "                                            #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"D\")\n",
    "                                            kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"D\")\n",
    "                                            print(\"Sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell, \"quantity is\",quant)\n",
    "                                            linkedlist_3.append(0,kite_drop)                \n",
    "                                            aqua1.remove(0)          \n",
    "                                            aqua1.append(1)\n",
    "                                        else:\n",
    "                                            pass\n",
    "                                    if 0 in redc:\n",
    "                                        update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                        match_in,=update_reverse[update_reverse.order_id==linkedlist_3[0]].index \n",
    "                                        match_in_int=int(match_in)\n",
    "                                        print(\"checking executed or not condition \")\n",
    "                                        if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                            quant=int(qu/2)\n",
    "                                            stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                            triggerprice_sell=stoploss_sell-sell_add\n",
    "                                            #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"E\")\n",
    "                                            kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"E\")\n",
    "                                            print(\" aqua Sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell, \"quantity is\",quant)\n",
    "                                            linkedlist_2.insert(0,kite_drop)            \n",
    "                                            aqua1.remove(0)\n",
    "                                            aqua1.append(2)              #------------------------ ( E )\n",
    "                                        else:\n",
    "                                            pass\n",
    "                                    else:\n",
    "                                        pass\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if \"red\" in gup.iloc[-1,5]:\n",
    "                            if 2 in counter:\n",
    "                                # (  PART B ) \n",
    "                                if 0 in redb:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu*2)\n",
    "                                        stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                        triggerprice_sell=stoploss_sell-sell_add\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"F\")\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"F\")\n",
    "                                        print(\" Sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell, \"quantity is\",quant)\n",
    "                                        linkedlist_1.insert(0,kite_drop)\n",
    "                                        counter.remove(2)\n",
    "                                        counter.append(3)\n",
    "                                        counter.append(1)        # #----------------------- ( F )\n",
    "                                        redb.remove(0)\n",
    "                                        checkfirst.append(0)\n",
    "                                        counter.append(10)\n",
    "                                        bluein.append(0)\n",
    "                                    else:\n",
    "                                        bid_not_ex=int(linkedlist_1[0])\n",
    "                                        print(\" aqua Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        print(\"now waiting for green again\")\n",
    "                                        linkedlist_1[0]=linkedlist_1[-1]\n",
    "                                        counter.remove(2)\n",
    "                                        counter.append(1)                                   \n",
    "                                        redb.remove(0)                      \n",
    "                                        checkfirst.append(0)\n",
    "                                        counter.append(10)\n",
    "                                # (  PART B )\n",
    "                                if 0 in redc:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_3[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu*2)\n",
    "                                        stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                        triggerprice_sell=stoploss_sell-sell_add\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"G\")\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"G\")\n",
    "                                        print(\" aqua Sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell, \"quantity is\",quant)\n",
    "                                        linkedlist_1.insert(0,kite_drop) \n",
    "                                        counter.remove(2)\n",
    "                                        counter.append(4)\n",
    "                                        counter.append(1)\n",
    "                                        redc.remove(0)\n",
    "                                        checkfirst.append(0)       #  ------------------------(  G )\n",
    "                                        counter.append(10)\n",
    "                                        bluein.append(0)\n",
    "                                    else:\n",
    "                                        bid_not_ex=int(linkedlist_3[0])\n",
    "                                        print(\" aqua Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        print(\"now waiting for green again\")\n",
    "                                        counter.remove(2)\n",
    "                                        counter.append(1)\n",
    "                                        redc.remove(0)\n",
    "                                        checkfirst.append(0)\n",
    "                                        counter.append(10)  \n",
    "                            else:\n",
    "                                pass\n",
    "                                               #   *********** checking condition 2nd time *************\n",
    "                        if 3 in counter:\n",
    "                            if 1 in aqua1:\n",
    "                                update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                match_in_int=int(match_in)\n",
    "                                print(\"checking executed or not condition \")\n",
    "                                if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_3[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu/2)\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"2Chk\")\n",
    "                                        print(\"both executed and market order placed comming from back again B and Z\")\n",
    "                                        aqua1.remove(1)\n",
    "                                    else:\n",
    "                                        print(\"not executed \")\n",
    "                                        bid_not_ex=int(linkedlist_3[0])\n",
    "                                        print(\" aqua Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        aqua1.remove(1)\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if 4 in counter:\n",
    "                            if 2 in aqua1:\n",
    "                                update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                match_in_int=int(match_in)\n",
    "                                print(\"checking executed or not condition \")\n",
    "                                if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_2[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu/2)\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"2BZ\")\n",
    "                                        print(\" G and E !both executed and market order placed comming from back again\", \"quantity is\",quant)\n",
    "                                        aqua1.remove(2)\n",
    "                                    else:\n",
    "                                        print(\"not executed \")\n",
    "                                        bid_not_ex=int(linkedlist_2[0])\n",
    "                                        print(\" aqua Cancel and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        aqua1.remove(2)\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if \"aqua\" in  gup.iloc[-1,5]:\n",
    "                            if 3 in counter:\n",
    "                                if 0 in bluein:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        print(\"ORDER COMPLETED and now SELL x/2\" )\n",
    "                                        quant=int(qu/2)\n",
    "                                        cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                        lim_price=cur_high+buy_add\n",
    "                                        print(\"Congrats !  Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"H\")\n",
    "                                        kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"H\")\n",
    "                                        linkedlist_2.insert(0,kite_drop)\n",
    "                                        blue_2F.append(1)                                       \n",
    "                                        bluein.remove(0)\n",
    "                                        bluez.append(0)\n",
    "                                        counter.remove(3)              # -------------------------- ( H )\n",
    "                                        counter.append(1)\n",
    "                                        count_sectime.append(1)\n",
    "                                    else:\n",
    "                                        pass\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if \"aqua\" in  gup.iloc[-1,5]:\n",
    "                            if 4 in counter:\n",
    "                                if 0 in bluein:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        print(\"ORDER COMPLETED and now SELL x/2\" )\n",
    "                                        quant=int(qu/2)\n",
    "                                        cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                        lim_price=cur_high+buy_add\n",
    "                                        print(\"Congrats ! Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"I\")\n",
    "                                        kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"I\")\n",
    "                                        linkedlist_2.insert(0,kite_drop)\n",
    "                                        blue_2G.append(1)                   \n",
    "                                        bluein.remove(0)           #----------------------- ( I )\n",
    "                                        bluez.append(0)\n",
    "                                        counter.remove(3)\n",
    "                                        counter.append(1)\n",
    "                                        count_sectime.append(1)\n",
    "                                    else:\n",
    "                                        pass\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        else:\n",
    "                            pass\n",
    "                        print(\" Orders Till Now \")\n",
    "        ashis()\n",
    "    if \"BUY\"==user or \"buy\"==user:\n",
    "        print(\"BOT STARTED WITH GREEN 'BUY' ENTRY after scanning \")\n",
    "        counter_start=[0]\n",
    "        linkedlist_1=[]       \n",
    "        linkedlist_2=[]      \n",
    "        linkedlist_3=[]      \n",
    "        counter=[0,10]      \n",
    "        checkfirst=[0]      \n",
    "        redb=[]             \n",
    "        bluez=[]            \n",
    "        aqua1=[0]           \n",
    "        bluein=[]           \n",
    "        blue_2F=[]          \n",
    "        blue_2G=[]          \n",
    "        count_sectime=[]\n",
    "        redc=[]\n",
    "        colourstill=[]\n",
    "        prog_starts=[]\n",
    "        #Variables\n",
    "        lst_candle=[]\n",
    "        lst_heikin_nor=[]\n",
    "        lst_heikin=[]\n",
    "        lst_cand=[]\n",
    "        lst_c=[]\n",
    "        anchor=0\n",
    "        countstart=0\n",
    "        #programe start\n",
    "        def ashibb():\n",
    "            while(True):\n",
    "                km=datetime.now().minute\n",
    "                ks=datetime.now().second\n",
    "                if km%1==0 and ks==1: \n",
    "                    now_utc = datetime.now(timezone('UTC'))\n",
    "                    now_asia = now_utc.astimezone(timezone('Asia/Kolkata'))\n",
    "                    now_asia = now_asia.strftime(\"%S \")\n",
    "                    klp1=now_asia\n",
    "                    #df=kite.historical_data(140033,sdate,todate,time_frame,0)\n",
    "                    dff=kite.historical_data(ttoken,sdate,todate,time_frame,0)\n",
    "                    dfw=pd.DataFrame(dff)\n",
    "                    df=pd.DataFrame(dfw[['date','open','high','low','close']])\n",
    "                    slow_ema = [3,5,7,9,11,13,15,17,19,21,23]\n",
    "                    fast_ema = [25,28,31,34,37,40,43,46,49,52,55,58,61,64,67,70,200]\n",
    "                    def EMA(df, base, target, period, alpha=False):\n",
    "                        con = pd.concat([df[:period][base].rolling(window=period).mean(), df[period:][base]])\n",
    "                        if (alpha == True):\n",
    "                            # (1 - alpha) * previous_val + alpha * current_val where alpha = 1 / period\n",
    "                            df[target] = con.ewm(alpha=1 / period, adjust=False).mean()\n",
    "                        else:\n",
    "                            # ((current_val - previous_val) * coeff) + previous_val where coeff = 2 / (period + 1)\n",
    "                            df[target] = con.ewm(span=period, adjust=False).mean()\n",
    "                        df.fillna(0,inplace = True)\n",
    "                    #     return df\n",
    "                    for j in slow_ema:\n",
    "                        val = \"ema\"+\"_\"+str(j)\n",
    "                        EMA(df,\"close\",val,j)\n",
    "                    for k in fast_ema:\n",
    "                        val = \"ema\"+\"_\"+str(k)\n",
    "                        EMA(df,\"close\",val,k)\n",
    "                    def super_guppy(interval,df,anchor=0):\n",
    "                    #     df['buy'] = 0\n",
    "                    #     df['sell'] = 0\n",
    "                    #     df['buybreak'] = 0\n",
    "                    #     df['sellbreak'] = 0\n",
    "                        anchor = 0\n",
    "                        ShowBreak = True\n",
    "                        ShowSwing = True\n",
    "                        ShowCon = False\n",
    "                        uOCCswing = False\n",
    "                        Lookback = 6\n",
    "                        emaFilter = False\n",
    "                        mult = 0\n",
    "                        buybreak = 0\n",
    "                        sellbreak = 0\n",
    "                        buy_barssince_var = 0\n",
    "                        sell_barssince_var = 0\n",
    "                        buybreak_barssince_var = 0\n",
    "                        sellbreak_barssince_var = 0\n",
    "                        barssince_lst = list()\n",
    "                        barssince_var = 0\n",
    "                        bar_count_var = 0\n",
    "                        buy1 = list()\n",
    "                        sell1 = list()\n",
    "                        buy2 = list()\n",
    "                        sell2 = list()\n",
    "                        buybreak1 = list()\n",
    "                        sellbreak1 = list()\n",
    "                        def barssince(b,barssince_var):\n",
    "                            barssince_lst = []\n",
    "                            barssince_var = 0 \n",
    "                            new_var = len(b)\n",
    "                            for i in b[::-1]:\n",
    "                                if i == 1:\n",
    "                                    break\n",
    "                                barssince_lst.append(i)\n",
    "                            barssince_var = len(barssince_lst)\n",
    "                            return barssince_var\n",
    "                            barssince_lst.clear()\n",
    "                        #isIntraday\n",
    "                        if interval < 1441 :\n",
    "                            if (anchor==0 or interval <= 0 or interval >= anchor or anchor > 1441 ):\n",
    "                                mult = 1\n",
    "                            else:\n",
    "                                if round(anchor/interval) > 1:\n",
    "                                    mult = round(anchor/interval)\n",
    "                                else:\n",
    "                                    mult = 1\n",
    "                        else:\n",
    "                            mult = 1\n",
    "                        #isIntraday Not\n",
    "                        if interval > 1441:\n",
    "                            if (anchor==0 or interval <= 0 or interval >= anchor or anchor < 52 ):\n",
    "                                mult = mult\n",
    "                            else:\n",
    "                                if round(anchor/interval) > 1:\n",
    "                                    mult = round(anchor/interval)\n",
    "                                else:\n",
    "                                    mult = 1\n",
    "                        else:\n",
    "                            mult = mult\n",
    "                        mult = 1\n",
    "                        for i in range(len(df)):\n",
    "                            emaF1 = df.loc[i,'ema_3']\n",
    "                            emaF2 = df.loc[i,'ema_5']\n",
    "                            emaF3 = df.loc[i,'ema_7']\n",
    "                            emaF4 = df.loc[i,'ema_9']\n",
    "                            emaF5 = df.loc[i,'ema_11']\n",
    "                            emaF6 = df.loc[i,'ema_13']\n",
    "                            emaF7 = df.loc[i,'ema_15']\n",
    "                            emaF8 = df.loc[i,'ema_17']\n",
    "                            emaF9 = df.loc[i,'ema_19']\n",
    "                            emaF10 = df.loc[i,'ema_21']\n",
    "                            emaF11 = df.loc[i,'ema_23']\n",
    "                            emaS1 = df.loc[i,'ema_25']\n",
    "                            emaS2 = df.loc[i,'ema_28']\n",
    "                            emaS3 = df.loc[i,'ema_31']\n",
    "                            emaS4 = df.loc[i,'ema_34']\n",
    "                            emaS5 = df.loc[i,'ema_37']\n",
    "                            emaS6 = df.loc[i,'ema_40']\n",
    "                            emaS7 = df.loc[i,'ema_43']\n",
    "                            emaS8 = df.loc[i,'ema_46']\n",
    "                            emaS9 = df.loc[i,'ema_49']\n",
    "                            emaS10 = df.loc[i,'ema_52']\n",
    "                            emaS11 = df.loc[i,'ema_55']\n",
    "                            emaS12 = df.loc[i,'ema_58']\n",
    "                            emaS13 = df.loc[i,'ema_61']\n",
    "                            emaS14 = df.loc[i,'ema_64']\n",
    "                            emaS15 = df.loc[i,'ema_67']\n",
    "                            emaS16 = df.loc[i,'ema_70']\n",
    "                            ema200 = df.loc[i,'ema_200'] \n",
    "                            emafast = (emaF1 + emaF2 + emaF3 + emaF4 + emaF5 + emaF6 + emaF7 + emaF8 + emaF9 + emaF10 + emaF11)/11\n",
    "                            emaslow = (emaS1 + emaS2 + emaS3 + emaS4 + emaS5 + emaS6 + emaS7 + emaS8 + emaS9 + emaS10 + emaS11 + emaS12 + emaS13 + emaS14 + emaS15 + emaS16)/16\n",
    "                            #Fast EMA Color Rules\n",
    "                            colfastL = (emaF1>emaF2 and emaF2>emaF3 and emaF3>emaF4 and emaF4>emaF5 and emaF5>emaF6 and emaF6>emaF7 and emaF7>emaF8 and emaF8>emaF9 and emaF9>emaF10 and emaF10>emaF11)\n",
    "                            colfastS = (emaF1<emaF2 and emaF2<emaF3 and emaF3<emaF4 and emaF4<emaF5 and emaF5<emaF6 and emaF6<emaF7 and emaF7<emaF8 and emaF8<emaF9 and emaF9<emaF10 and emaF10<emaF11)\n",
    "                            #Slow EMA Color Rules\n",
    "                            colslowL = (emaS1>emaS2 and emaS2>emaS3 and emaS3>emaS4 and emaS4>emaS5 and emaS5>emaS6 and emaS6>emaS7 and emaS7>emaS8) and (emaS8>emaS9 and emaS9>emaS10 and emaS10>emaS11 and emaS11>emaS12 and emaS12>emaS13 and emaS13>emaS14 and emaS14>emaS15 and emaS15>emaS16)\n",
    "                            colslowS = (emaS1<emaS2 and emaS2<emaS3 and emaS3<emaS4 and emaS4<emaS5 and emaS5<emaS6 and emaS6<emaS7 and emaS7<emaS8) and (emaS8<emaS9 and emaS9<emaS10 and emaS10<emaS11 and emaS11<emaS12 and emaS12<emaS13 and emaS13<emaS14 and emaS14<emaS15 and emaS15<emaS16)\n",
    "                            if  emafast > emaslow and not colslowS and colfastL and (not ShowCon or colslowL) and (not emaFilter or emafast>ema200):\n",
    "                                if int(buy1[-1]) > 0:\n",
    "                                    buy = buy1[-1] + 1\n",
    "                                else:\n",
    "                                    buy = 1\n",
    "                            else:\n",
    "                                buy = 0\n",
    "                            buy1.append(buy)\n",
    "                            if  emafast < emaslow and not colslowL and colfastS and (not ShowCon or colslowS) and (not emaFilter or emafast<ema200):\n",
    "                                if int(sell1[-1]) > 0:\n",
    "                                    sell = sell1[-1] + 1\n",
    "                                else:\n",
    "                                    sell = 1\n",
    "                            else:\n",
    "                                sell = 0\n",
    "                            sell1.append(sell)\n",
    "                            #buy\n",
    "                            if buy>1 and colfastL and (uOCCswing and ((df.loc[i-1,'close']<df.loc[i-1,'open']) and (df.loc[i,'close']>df.loc[i,'open']))):\n",
    "                                buy3 = 1\n",
    "                            else:\n",
    "                                buy3 = buy\n",
    "                            buy2.append(buy3)\n",
    "                            #sell    \n",
    "                            if sell>1 and colfastS and (uOCCswing and ((df.loc[i-1,'close']<df.loc[i-1,'open']) and (df.loc[i,'close']>df.loc[i,'open']))):\n",
    "                                sell3 = 1\n",
    "                            else:\n",
    "                                sell3 = sell\n",
    "                            sell2.append(sell3)\n",
    "                            #buybreak\n",
    "                            if emafast > emaslow and not colslowS and (not emaFilter or emafast>ema200):\n",
    "                                if buybreak1[-1] > 0:\n",
    "                                    buybreak = buybreak1[-1] + 1\n",
    "                                else:\n",
    "                                    buybreak = 1\n",
    "                            else:\n",
    "                                buybreak = 0\n",
    "                            buybreak1.append(buybreak)\n",
    "                            if emafast < emaslow and not colslowL and (not emaFilter or emafast<ema200):\n",
    "                                if sellbreak1[-1] > 0:\n",
    "                                    sellbreak = sellbreak1[-1]+1\n",
    "                                else:\n",
    "                                    sellbreak = 1\n",
    "                            else:\n",
    "                                sellbreak = 0\n",
    "                            sellbreak1.append(sellbreak)\n",
    "                            #arrow plotting\n",
    "                            #buy_arrow\n",
    "                            buy_barssince_var = barssince(buy2[:-1],barssince_var)\n",
    "                            if (ShowSwing and buy3==1)and buy_barssince_var > 6:\n",
    "                                buy_arrow = 1\n",
    "                            else:\n",
    "                                buy_arrow = 0\n",
    "                            #sell arrow\n",
    "                            sell_barssince_var = barssince(sell2[:-1],barssince_var)\n",
    "                            if ShowSwing and (sell3==1 and sell_barssince_var > 6):\n",
    "                                sell_arrow = 1\n",
    "                            else:\n",
    "                                sell_arrow = 0\n",
    "                            #buybreak_arrow\n",
    "                            buybreak_barssince_var = barssince(buybreak1[:-1],barssince_var)\n",
    "                            sellbreak_barssince_var = barssince(sellbreak1[:-1],barssince_var)\n",
    "\n",
    "                            if ShowBreak and buybreak==1 and (sellbreak_barssince_var>Lookback) and (buybreak_barssince_var>Lookback):\n",
    "                                buybreak_arrow = 1\n",
    "                            else:\n",
    "                                buybreak_arrow = 0\n",
    "                            #sellbreak_arrow\n",
    "                            if ShowBreak and sellbreak==1 and (buybreak_barssince_var>Lookback) and (sellbreak_barssince_var>Lookback):\n",
    "                                sellbreak_arrow = 1\n",
    "                            else:\n",
    "                                sellbreak_arrow = 0\n",
    "                            if buy_arrow==1 and sell_arrow==0 and buybreak_arrow==0 and sellbreak_arrow==0:\n",
    "                                arrow_color = 'green'\n",
    "                            elif buy_arrow==0 and sell_arrow==1 and buybreak_arrow==0 and sellbreak_arrow==0:\n",
    "                                arrow_color = 'red'\n",
    "                            elif sell_arrow==0 and (buy_arrow==0 or buy_arrow==1) and buybreak_arrow==1 and sellbreak_arrow==0:\n",
    "                                arrow_color = 'aqua'\n",
    "                            elif buy_arrow==0 and (sell_arrow==1 or sell_arrow==0) and buybreak_arrow==0 and sellbreak_arrow==1:\n",
    "                                arrow_color = 'blue'\n",
    "                            else:\n",
    "                                arrow_color = 'none'\n",
    "                            df.loc[i,'arrow_color'] = arrow_color\n",
    "                        df = df[['date','open','high','low','close','arrow_color']]\n",
    "                        return df\n",
    "                    df=super_guppy(15,df)\n",
    "                    gup=pd.DataFrame(df)\n",
    "                    def bidatrema(df,period):\n",
    "                        df['hl']=abs(df['high']-df['low'])\n",
    "                        df['hpc']=abs(df['high']-df['close'].shift())\n",
    "                        df['lpc']=abs(df['low']-df['close'].shift())\n",
    "                        df['tr']=df[['hl','hpc','lpc']].max(axis=1)\n",
    "                        df['ATR']=pd.DataFrame.ewm(df[\"tr\"], span=period,min_periods=period).mean()\n",
    "                        df.drop([\"hl\",\"hpc\",\"lpc\",\"tr\"],axis = 1 , inplace =True)\n",
    "                    bidatrema(gup,14)\n",
    "                    print(\" \\n \\t \\t \\t \\t  ZERODHA GUPPY BOT \")\n",
    "                    print(\" \\t \\t \\t \\n Current Colour on this token is \" , gup.iloc[-1,5])\n",
    "                    now_utc = datetime.now(timezone('UTC'))\n",
    "                    now_asia = now_utc.astimezone(timezone('Asia/Kolkata'))\n",
    "                    now_asia = now_asia.strftime(\"%Y-%m-%d _ %H:%M:%S \")\n",
    "                    klp1=now_asia\n",
    "                    prog_starts.append(klp1)\n",
    "                    print(\"\\n \")\n",
    "                    print(\"Zerodha GUPPY BOT start Time             \"  , prog_starts[0])\n",
    "                    print(\"\\n \")\n",
    "                    print(\"BOT working succeesfully on time:        \"  , now_asia )\n",
    "                    print(\"\\n \")\n",
    "                    print(\"Trading symbol is\",ttradingsymbol,\"Token is\",ttoken,\"Exchange is\",eexchange,\"and product type is\",productt,\"Quantity is\",qu,\"time frame for Historical Data is\",time_frame,\"Starting and Ending Date of Historical Data is\",sdate,todate)\n",
    "                    \n",
    "                    colourstill.append(gup.iloc[-1,5])\n",
    "                    print(\"\\n \")\n",
    "                    print(\"\\n \")\n",
    "                    if 0 in counter_start:\n",
    "                        if \"green\" in  gup.iloc[-1,5]:\n",
    "                            counter_start.remove(0)\n",
    "                            counter_start.append(1)\n",
    "                        else:\n",
    "                            pass\n",
    "                    if 1 in counter_start:\n",
    "                        print(\" BOT STARTED WITH GREEN ENTRY \")\n",
    "                        if \"blank\" in gup.iloc[-1,5]:\n",
    "                            print(\" Nothing Done BUT BOT started no candel colour occur \")\n",
    "                        if \"green\" in gup.iloc[-1,5]:\n",
    "                            if 0 in counter:\n",
    "                                #BUY X amount                   #-------------------------------------------------------- (A)\n",
    "                                quant=qu\n",
    "                                cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                lim_price=cur_high+buy_add\n",
    "                                print(\"Congrats ! No1 Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"A\")\n",
    "                                kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"G1\") \n",
    "                                linkedlist_1.insert(0,kite_drop)\n",
    "                                counter.remove(0)\n",
    "                                counter.append(1)\n",
    "\n",
    "                        if \"blue\" in gup.iloc[-1,5]:\n",
    "                            if 1 in counter:\n",
    "                                if 10 in counter:\n",
    "                                    print(\"Blue Comes checking blue condition @ is previous green executed or not ?\") # (A)\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:   \n",
    "                                        print(\"ORDER COMPLETED and now SELL x/2\" )\n",
    "                                        quant=int(qu/2)\n",
    "                                        stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                        triggerprice_sell=stoploss_sell-sell_add\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"Z\")\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"Z\")\n",
    "                                        print(\"No2 BLUE Sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell, \"quantity is\",quant)\n",
    "                                        linkedlist_2.insert(0,kite_drop)\n",
    "                                        counter.remove(10) # -------------------------- ( Z )\n",
    "                                        bluez.append(0)\n",
    "                                    else:\n",
    "                                        print(\" BUY not executed  \")\n",
    "                        if \"red\" in gup.iloc[-1,5]:\n",
    "                            if 1 in counter:                                              \n",
    "                                print(\"checking previous green executed or not \") \n",
    "                                update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                match_in_int=int(match_in)\n",
    "                                print(\"checking executed or not condition \")\n",
    "                                if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:   \n",
    "                                    print(\"ORDER COMPLETED and now SELL x/2\" )\n",
    "                                    quant=int(2*qu)\n",
    "                                    stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                    triggerprice_sell=stoploss_sell-sell_add\n",
    "                                    #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"B\")\n",
    "                                    kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"B\")\n",
    "                                    print(\"No3 RED Sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell, \"quantity is\",quant)\n",
    "                                    linkedlist_1.insert(0,kite_drop)\n",
    "                                    counter.remove(1)\n",
    "                                    counter.append(2)\n",
    "                                    redb.append(0)                                 # ------------------------ ( B )\n",
    "                                else:\n",
    "                                    print(\"BLUE bid not complete now canceled bule bid and place fresh sell of x amount\")\n",
    "                                    bid_not_ex=int(linkedlist_1[0])\n",
    "                                    print(\"SL Cancel Order cancelled and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                    stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                    triggerprice_sell=stoploss_sell-5\n",
    "                                    #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=qu,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"C\")\n",
    "                                    kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=qu,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"C\")\n",
    "                                    print(\"No1 C fresh start Sell Stoploss order placed\", \"quantity is\",qu ,\"and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell)\n",
    "                                    linkedlist_3.insert(0,kite_drop)     \n",
    "                                    counter.remove(1)\n",
    "                                    counter.append(2)     #  ------------ -------------- ( C )\n",
    "                                    redc.append(0) \n",
    "                                               #       *********************** checking condition *********************\n",
    "                        if 0 in bluez: \n",
    "                            if 2 in counter:\n",
    "                                if 0 in checkfirst:\n",
    "                                    print(\" RED placed and now checking RED executed or not condition \")\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        print(\" RED executed \")\n",
    "                                        print(\" Now checking  BLUE executed or not\")\n",
    "                                        update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                        match_in,=update_reverse[update_reverse.order_id==linkedlist_2[0]].index \n",
    "                                        match_in_int=int(match_in)\n",
    "                                        if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                            print(\" yes BLUE executed \")\n",
    "                                            print(\" BOTH blue and RED executed and now placig order qu/2 \")\n",
    "                                            quant=int(qu/2)\n",
    "                                            stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                            triggerprice_sell=stoploss_sell-sell_add\n",
    "                                            kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"BZ\")\n",
    "                                            print(\"Z and B both executed and market order placed\", \"quantity is\",quant)\n",
    "                                        else:\n",
    "                                            print(\"Z not executed \")\n",
    "                                            bid_not_ex=int(linkedlist_2[0])\n",
    "                                            print(\" blue Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                    else:\n",
    "                                        pass\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                                                   #  *************** comming from back ****************   \n",
    "                        if 0 in count_sectime:\n",
    "                            if 2 in counnter:\n",
    "                                update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                match_in_int=int(match_in)\n",
    "                                print(\"checking executed or not condition \")\n",
    "                                if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_2[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu/2)\n",
    "                                        stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                        triggerprice_sell=stoploss_sell-sell_add\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"BZ\")\n",
    "                                        print(\"both executed and market order placed comming from back again\", \"quantity is\",quant)\n",
    "                                        count_sectime.remove(1)\n",
    "                                    else:\n",
    "                                        print(\"Z not executed \")\n",
    "                                        bid_not_ex=int(linkedlist_2[0])\n",
    "                                        print(\" blue Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        count_sectime.remove(1)\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if \"aqua\" in gup.iloc[-1,5]:\n",
    "                            if 2 in counter:\n",
    "                                if 0 in aqua1:\n",
    "                                    if 0 in redb:\n",
    "                                        update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                        match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                        match_in_int=int(match_in)\n",
    "                                        print(\"checking executed or not condition \")\n",
    "                                        if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                            quant=int(qu/2)\n",
    "                                            cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                            lim_price=cur_high+buy_add\n",
    "                                            print(\"Congrats ! Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                            kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"F\") \n",
    "                                            print(\"in aqua and one BUY LIMIT oreder placed \",  \"quantity is\",quant)\n",
    "                                            linkedlist_3.append(0,kite_drop)                \n",
    "                                            aqua1.remove(0)          \n",
    "                                            aqua1.append(1)    #------------------------------ ( D )\n",
    "                                        else:\n",
    "                                            pass\n",
    "                                    if 0 in redc:\n",
    "                                        update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                        match_in,=update_reverse[update_reverse.order_id==linkedlist_3[0]].index \n",
    "                                        match_in_int=int(match_in)\n",
    "                                        print(\"checking executed or not condition \")\n",
    "                                        if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                            quant=int(qu/2)\n",
    "                                            cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                            lim_price=cur_high+buy_add\n",
    "                                            print(\"Congrats ! E , No1 Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                            #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"E\")\n",
    "                                            kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"E\") \n",
    "                                            linkedlist_2.insert(0,kite_drop)            \n",
    "                                            aqua1.remove(0)\n",
    "                                            aqua1.append(2)              #------------------------ ( E )\n",
    "                                        else:\n",
    "                                            pass\n",
    "                                    else:\n",
    "                                        pass\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if \"green\" in gup.iloc[-1,5]:\n",
    "                            if 2 in counter:\n",
    "                                # (  PART B ) \n",
    "                                if 0 in redb:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu*2)\n",
    "                                        cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                        lim_price=cur_high+buy_add\n",
    "                                        print(\"Congrats ! F Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"F\")\n",
    "                                        kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"F\") \n",
    "                                        linkedlist_1.insert(0,kite_drop)\n",
    "                                        counter.remove(2)\n",
    "                                        counter.append(3)\n",
    "                                        counter.append(1)\n",
    "                                        redb.remove(0)             # ---------------------------( F )\n",
    "                                        checkfirst.append(0)\n",
    "                                        counter.append(10)\n",
    "                                        bluein.append(0)\n",
    "                                    else:\n",
    "                                        bid_not_ex=int(linkedlist_1[0])\n",
    "                                        print(\" blue Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        print(\"now waiting for red again\")\n",
    "                                        linkedlist_1[0]=linkedlist_1[-1]\n",
    "                                        counter.remove(2)\n",
    "                                        counter.append(1)                                   \n",
    "                                        redb.remove(0)                      \n",
    "                                        checkfirst.append(0)\n",
    "                                        counter.append(10)\n",
    "                                # (  PART B )\n",
    "                                if 0 in redc:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_3[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu*2)\n",
    "                                        cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                        lim_price=cur_high+buy_add\n",
    "                                        print(\"Congrats ! G Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"G\")\n",
    "                                        kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"G\") \n",
    "                                        linkedlist_1.insert(0,kite_drop) \n",
    "                                        counter.remove(2)\n",
    "                                        counter.append(4)\n",
    "                                        counter.append(1)\n",
    "                                        redc.remove(0)\n",
    "                                        checkfirst.append(0)       #  ------------------------(  G )\n",
    "                                        counter.append(10)\n",
    "                                        bluein.append(0)\n",
    "                                    else:\n",
    "                                        bid_not_ex=int(linkedlist_3[0])\n",
    "                                        print(\" blue Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        print(\"now waiting for red again\")\n",
    "                                        counter.remove(2)\n",
    "                                        counter.append(1)\n",
    "                                        redc.remove(0)\n",
    "                                        checkfirst.append(0)\n",
    "                                        counter.append(10)  \n",
    "                            else:\n",
    "                                pass\n",
    "                        #  *************** checking condition 2nd time *************\n",
    "                        if 3 in counter:\n",
    "                            if 1 in aqua1:\n",
    "                                update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                match_in_int=int(match_in)\n",
    "                                print(\"checking executed or not condition \")\n",
    "                                if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_3[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu/2)\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"2Chk\")\n",
    "                                        print(\"both executed and market order placed comming from back again B and Z\")\n",
    "                                        aqua1.remove(1)\n",
    "                                    else:\n",
    "                                        print(\"not executed \")\n",
    "                                        bid_not_ex=int(linkedlist_3[0])\n",
    "                                        print(\" blue Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        aqua1.remove(1)\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if 4 in counter:\n",
    "                            if 2 in aqua1:\n",
    "                                update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                match_in_int=int(match_in)\n",
    "                                print(\"checking executed or not condition \")\n",
    "                                if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_2[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu/2)\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"2BZ\")\n",
    "                                        print(\" G and E !both executed and market order placed comming from back again\", \"quantity is\",quant)\n",
    "                                        aqua1.remove(2)\n",
    "                                    else:\n",
    "                                        print(\"not executed \")\n",
    "                                        bid_not_ex=int(linkedlist_2[0])\n",
    "                                        print(\" blue Cancel and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        aqua1.remove(2)\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if \"blue\" in  gup.iloc[-1,5]:\n",
    "                            if 3 in counter:\n",
    "                                if 0 in bluein:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        print(\"ORDER COMPLETED and now SELL x/2\" )\n",
    "                                        quant=int(qu/2)\n",
    "                                        stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                        triggerprice_sell=stoploss_sell-sell_add\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"H\")\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"H\")\n",
    "                                        print( \"quantity is\",quant,\" H blue Sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell)\n",
    "                                        linkedlist_2.insert(0,kite_drop)\n",
    "                                        blue_2F.append(1)                                       \n",
    "                                        bluein.remove(0)\n",
    "                                        bluez.append(0)\n",
    "                                        counter.remove(3)              # -------------------------- ( H )\n",
    "                                        counter.append(1)\n",
    "                                        count_sectime.append(1)\n",
    "                                    else:\n",
    "                                        pass\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if \"blue\" in  gup.iloc[-1,5]:\n",
    "                            if 4 in counter:\n",
    "                                if 0 in bluein:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        print(\"ORDER COMPLETED and now SELL x/2\" )\n",
    "                                        quant=int(qu/2)\n",
    "                                        stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                        triggerprice_sell=stoploss_sell-sell_add\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"I\")\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"I\")\n",
    "                                        print( \"quantity is\",quant,\"I blue Sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell)\n",
    "                                        linkedlist_2.insert(0,kite_drop)\n",
    "                                        blue_2G.append(1)                   \n",
    "                                        bluein.remove(0)           #----------------------- ( I )\n",
    "                                        bluez.append(0)\n",
    "                                        counter.remove(3)\n",
    "                                        counter.append(1)\n",
    "                                        count_sectime.append(1)\n",
    "                                    else:\n",
    "                                        pass\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        else:\n",
    "                            pass\n",
    "                    print(\"Colours Till Now\")\n",
    "                    print(colourstill)\n",
    "                    #display(pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"transaction_type\",\"status\",\"order_id\",\"quantity\",\"order_type\",\"exchange_update_timestamp\",'tag',\"quantity\"]].tail(10))\n",
    "        ashibb()\n",
    "if \"NO\"==scan or \"no\"==scan:\n",
    "    print(\"BOT STARTED WITHOUT SCREENER\")\n",
    "    print(\"\\n\")\n",
    "    print(\" which BOT you want to run ? BUY  \\ SELL\")\n",
    "    without=str(input(\" BUY  \\ SELL :- \" ))\n",
    "    print(\" ** ENTER ALL DETAILS IN CAPITAL LETTERS ONLY **\")\n",
    "    ttradingsymbol =str(input(\"ENTER TRADINGSYMBOL - SUNPHARMA / SBIN :- \"))\n",
    "    eexchange      =str(input(\"ENTER EXCHANGE - NSE / BSE / CDS  :-\"))\n",
    "    productt       =str(input(\"ENTER PRODUCT - NRML /CNC / MIS  :-\"))\n",
    "    qu             =int(input(\"ENTER QUANTITY - 2 / 4 :-\"))\n",
    "    time_frame     =str(input(\"ENTER TIMEFRAME - minute / 5minute **small letters only** :- \"))\n",
    "    sdate          =\"2019-06-05\"\n",
    "    todate         =\"2020-10-02\"\n",
    "    buy_add=.50\n",
    "    sell_add=.50\n",
    "    ttoken=int(pd.DataFrame(kite.ltp(eexchange+\":\"+ttradingsymbol)).iloc[-2,0])\n",
    "    if \"BUY\"==without or \"buy\"==without:\n",
    "        print(\"BOT STARTED WITH GREEN 'BUY' ENTRY  \")\n",
    "        counter_start=[0]\n",
    "        linkedlist_1=[]       \n",
    "        linkedlist_2=[]      \n",
    "        linkedlist_3=[]      \n",
    "        counter=[0,10]      \n",
    "        checkfirst=[0]      \n",
    "        redb=[]             \n",
    "        bluez=[]            \n",
    "        aqua1=[0]           \n",
    "        bluein=[]           \n",
    "        blue_2F=[]          \n",
    "        blue_2G=[]          \n",
    "        count_sectime=[]\n",
    "        redc=[]\n",
    "        colourstill=[]\n",
    "        prog_starts=[]\n",
    "        #Variables\n",
    "        lst_candle=[]\n",
    "        lst_heikin_nor=[]\n",
    "        lst_heikin=[]\n",
    "        lst_cand=[]\n",
    "        lst_c=[]\n",
    "        anchor=0\n",
    "        countstart=0\n",
    "        #programe start\n",
    "        def ashibb():\n",
    "            while(True):\n",
    "                km=datetime.now().minute\n",
    "                ks=datetime.now().second\n",
    "                if km%1==0 and ks==1:\n",
    "                    clear_output(wait=True)  \n",
    "                    now_utc = datetime.now(timezone('UTC'))\n",
    "                    now_asia = now_utc.astimezone(timezone('Asia/Kolkata'))\n",
    "                    now_asia = now_asia.strftime(\"%S \")\n",
    "                    klp1=now_asia\n",
    "                    #df=kite.historical_data(140033,sdate,todate,time_frame,0)\n",
    "                    dff=kite.historical_data(ttoken,sdate,todate,time_frame,0)\n",
    "                    dfw=pd.DataFrame(dff)\n",
    "                    df=pd.DataFrame(dfw[['date','open','high','low','close']])\n",
    "                    slow_ema = [3,5,7,9,11,13,15,17,19,21,23]\n",
    "                    fast_ema = [25,28,31,34,37,40,43,46,49,52,55,58,61,64,67,70,200]\n",
    "                    def EMA(df, base, target, period, alpha=False):\n",
    "                        con = pd.concat([df[:period][base].rolling(window=period).mean(), df[period:][base]])\n",
    "                        if (alpha == True):\n",
    "                            # (1 - alpha) * previous_val + alpha * current_val where alpha = 1 / period\n",
    "                            df[target] = con.ewm(alpha=1 / period, adjust=False).mean()\n",
    "                        else:\n",
    "                            # ((current_val - previous_val) * coeff) + previous_val where coeff = 2 / (period + 1)\n",
    "                            df[target] = con.ewm(span=period, adjust=False).mean()\n",
    "                        df.fillna(0,inplace = True)\n",
    "                    #     return df\n",
    "                    for j in slow_ema:\n",
    "                        val = \"ema\"+\"_\"+str(j)\n",
    "                        EMA(df,\"close\",val,j)\n",
    "                    for k in fast_ema:\n",
    "                        val = \"ema\"+\"_\"+str(k)\n",
    "                        EMA(df,\"close\",val,k)\n",
    "                    def super_guppy(interval,df,anchor=0):\n",
    "                    #     df['buy'] = 0\n",
    "                    #     df['sell'] = 0\n",
    "                    #     df['buybreak'] = 0\n",
    "                    #     df['sellbreak'] = 0\n",
    "                        anchor = 0\n",
    "                        ShowBreak = True\n",
    "                        ShowSwing = True\n",
    "                        ShowCon = False\n",
    "                        uOCCswing = False\n",
    "                        Lookback = 6\n",
    "                        emaFilter = False\n",
    "                        mult = 0\n",
    "                        buybreak = 0\n",
    "                        sellbreak = 0\n",
    "                        buy_barssince_var = 0\n",
    "                        sell_barssince_var = 0\n",
    "                        buybreak_barssince_var = 0\n",
    "                        sellbreak_barssince_var = 0\n",
    "                        barssince_lst = list()\n",
    "                        barssince_var = 0\n",
    "                        bar_count_var = 0\n",
    "                        buy1 = list()\n",
    "                        sell1 = list()\n",
    "                        buy2 = list()\n",
    "                        sell2 = list()\n",
    "                        buybreak1 = list()\n",
    "                        sellbreak1 = list()\n",
    "                        def barssince(b,barssince_var):\n",
    "                            barssince_lst = []\n",
    "                            barssince_var = 0 \n",
    "                            new_var = len(b)\n",
    "                            for i in b[::-1]:\n",
    "                                if i == 1:\n",
    "                                    break\n",
    "                                barssince_lst.append(i)\n",
    "                            barssince_var = len(barssince_lst)\n",
    "                            return barssince_var\n",
    "                            barssince_lst.clear()\n",
    "                        #isIntraday\n",
    "                        if interval < 1441 :\n",
    "                            if (anchor==0 or interval <= 0 or interval >= anchor or anchor > 1441 ):\n",
    "                                mult = 1\n",
    "                            else:\n",
    "                                if round(anchor/interval) > 1:\n",
    "                                    mult = round(anchor/interval)\n",
    "                                else:\n",
    "                                    mult = 1\n",
    "                        else:\n",
    "                            mult = 1\n",
    "                        #isIntraday Not\n",
    "                        if interval > 1441:\n",
    "                            if (anchor==0 or interval <= 0 or interval >= anchor or anchor < 52 ):\n",
    "                                mult = mult\n",
    "                            else:\n",
    "                                if round(anchor/interval) > 1:\n",
    "                                    mult = round(anchor/interval)\n",
    "                                else:\n",
    "                                    mult = 1\n",
    "                        else:\n",
    "                            mult = mult\n",
    "                        mult = 1\n",
    "                        for i in range(len(df)):\n",
    "                            emaF1 = df.loc[i,'ema_3']\n",
    "                            emaF2 = df.loc[i,'ema_5']\n",
    "                            emaF3 = df.loc[i,'ema_7']\n",
    "                            emaF4 = df.loc[i,'ema_9']\n",
    "                            emaF5 = df.loc[i,'ema_11']\n",
    "                            emaF6 = df.loc[i,'ema_13']\n",
    "                            emaF7 = df.loc[i,'ema_15']\n",
    "                            emaF8 = df.loc[i,'ema_17']\n",
    "                            emaF9 = df.loc[i,'ema_19']\n",
    "                            emaF10 = df.loc[i,'ema_21']\n",
    "                            emaF11 = df.loc[i,'ema_23']\n",
    "                            emaS1 = df.loc[i,'ema_25']\n",
    "                            emaS2 = df.loc[i,'ema_28']\n",
    "                            emaS3 = df.loc[i,'ema_31']\n",
    "                            emaS4 = df.loc[i,'ema_34']\n",
    "                            emaS5 = df.loc[i,'ema_37']\n",
    "                            emaS6 = df.loc[i,'ema_40']\n",
    "                            emaS7 = df.loc[i,'ema_43']\n",
    "                            emaS8 = df.loc[i,'ema_46']\n",
    "                            emaS9 = df.loc[i,'ema_49']\n",
    "                            emaS10 = df.loc[i,'ema_52']\n",
    "                            emaS11 = df.loc[i,'ema_55']\n",
    "                            emaS12 = df.loc[i,'ema_58']\n",
    "                            emaS13 = df.loc[i,'ema_61']\n",
    "                            emaS14 = df.loc[i,'ema_64']\n",
    "                            emaS15 = df.loc[i,'ema_67']\n",
    "                            emaS16 = df.loc[i,'ema_70']\n",
    "                            ema200 = df.loc[i,'ema_200'] \n",
    "                            emafast = (emaF1 + emaF2 + emaF3 + emaF4 + emaF5 + emaF6 + emaF7 + emaF8 + emaF9 + emaF10 + emaF11)/11\n",
    "                            emaslow = (emaS1 + emaS2 + emaS3 + emaS4 + emaS5 + emaS6 + emaS7 + emaS8 + emaS9 + emaS10 + emaS11 + emaS12 + emaS13 + emaS14 + emaS15 + emaS16)/16\n",
    "                            #Fast EMA Color Rules\n",
    "                            colfastL = (emaF1>emaF2 and emaF2>emaF3 and emaF3>emaF4 and emaF4>emaF5 and emaF5>emaF6 and emaF6>emaF7 and emaF7>emaF8 and emaF8>emaF9 and emaF9>emaF10 and emaF10>emaF11)\n",
    "                            colfastS = (emaF1<emaF2 and emaF2<emaF3 and emaF3<emaF4 and emaF4<emaF5 and emaF5<emaF6 and emaF6<emaF7 and emaF7<emaF8 and emaF8<emaF9 and emaF9<emaF10 and emaF10<emaF11)\n",
    "                            #Slow EMA Color Rules\n",
    "                            colslowL = (emaS1>emaS2 and emaS2>emaS3 and emaS3>emaS4 and emaS4>emaS5 and emaS5>emaS6 and emaS6>emaS7 and emaS7>emaS8) and (emaS8>emaS9 and emaS9>emaS10 and emaS10>emaS11 and emaS11>emaS12 and emaS12>emaS13 and emaS13>emaS14 and emaS14>emaS15 and emaS15>emaS16)\n",
    "                            colslowS = (emaS1<emaS2 and emaS2<emaS3 and emaS3<emaS4 and emaS4<emaS5 and emaS5<emaS6 and emaS6<emaS7 and emaS7<emaS8) and (emaS8<emaS9 and emaS9<emaS10 and emaS10<emaS11 and emaS11<emaS12 and emaS12<emaS13 and emaS13<emaS14 and emaS14<emaS15 and emaS15<emaS16)\n",
    "                            if  emafast > emaslow and not colslowS and colfastL and (not ShowCon or colslowL) and (not emaFilter or emafast>ema200):\n",
    "                                if int(buy1[-1]) > 0:\n",
    "                                    buy = buy1[-1] + 1\n",
    "                                else:\n",
    "                                    buy = 1\n",
    "                            else:\n",
    "                                buy = 0\n",
    "                            buy1.append(buy)\n",
    "                            if  emafast < emaslow and not colslowL and colfastS and (not ShowCon or colslowS) and (not emaFilter or emafast<ema200):\n",
    "                                if int(sell1[-1]) > 0:\n",
    "                                    sell = sell1[-1] + 1\n",
    "                                else:\n",
    "                                    sell = 1\n",
    "                            else:\n",
    "                                sell = 0\n",
    "                            sell1.append(sell)\n",
    "                            #buy\n",
    "                            if buy>1 and colfastL and (uOCCswing and ((df.loc[i-1,'close']<df.loc[i-1,'open']) and (df.loc[i,'close']>df.loc[i,'open']))):\n",
    "                                buy3 = 1\n",
    "                            else:\n",
    "                                buy3 = buy\n",
    "                            buy2.append(buy3)\n",
    "                            #sell    \n",
    "                            if sell>1 and colfastS and (uOCCswing and ((df.loc[i-1,'close']<df.loc[i-1,'open']) and (df.loc[i,'close']>df.loc[i,'open']))):\n",
    "                                sell3 = 1\n",
    "                            else:\n",
    "                                sell3 = sell\n",
    "                            sell2.append(sell3)\n",
    "                            #buybreak\n",
    "                            if emafast > emaslow and not colslowS and (not emaFilter or emafast>ema200):\n",
    "                                if buybreak1[-1] > 0:\n",
    "                                    buybreak = buybreak1[-1] + 1\n",
    "                                else:\n",
    "                                    buybreak = 1\n",
    "                            else:\n",
    "                                buybreak = 0\n",
    "                            buybreak1.append(buybreak)\n",
    "                            if emafast < emaslow and not colslowL and (not emaFilter or emafast<ema200):\n",
    "                                if sellbreak1[-1] > 0:\n",
    "                                    sellbreak = sellbreak1[-1]+1\n",
    "                                else:\n",
    "                                    sellbreak = 1\n",
    "                            else:\n",
    "                                sellbreak = 0\n",
    "                            sellbreak1.append(sellbreak)\n",
    "                            #arrow plotting\n",
    "                            #buy_arrow\n",
    "                            buy_barssince_var = barssince(buy2[:-1],barssince_var)\n",
    "                            if (ShowSwing and buy3==1)and buy_barssince_var > 6:\n",
    "                                buy_arrow = 1\n",
    "                            else:\n",
    "                                buy_arrow = 0\n",
    "                            #sell arrow\n",
    "                            sell_barssince_var = barssince(sell2[:-1],barssince_var)\n",
    "                            if ShowSwing and (sell3==1 and sell_barssince_var > 6):\n",
    "                                sell_arrow = 1\n",
    "                            else:\n",
    "                                sell_arrow = 0\n",
    "                            #buybreak_arrow\n",
    "                            buybreak_barssince_var = barssince(buybreak1[:-1],barssince_var)\n",
    "                            sellbreak_barssince_var = barssince(sellbreak1[:-1],barssince_var)\n",
    "\n",
    "                            if ShowBreak and buybreak==1 and (sellbreak_barssince_var>Lookback) and (buybreak_barssince_var>Lookback):\n",
    "                                buybreak_arrow = 1\n",
    "                            else:\n",
    "                                buybreak_arrow = 0\n",
    "                            #sellbreak_arrow\n",
    "                            if ShowBreak and sellbreak==1 and (buybreak_barssince_var>Lookback) and (sellbreak_barssince_var>Lookback):\n",
    "                                sellbreak_arrow = 1\n",
    "                            else:\n",
    "                                sellbreak_arrow = 0\n",
    "                            if buy_arrow==1 and sell_arrow==0 and buybreak_arrow==0 and sellbreak_arrow==0:\n",
    "                                arrow_color = 'green'\n",
    "                            elif buy_arrow==0 and sell_arrow==1 and buybreak_arrow==0 and sellbreak_arrow==0:\n",
    "                                arrow_color = 'red'\n",
    "                            elif sell_arrow==0 and (buy_arrow==0 or buy_arrow==1) and buybreak_arrow==1 and sellbreak_arrow==0:\n",
    "                                arrow_color = 'aqua'\n",
    "                            elif buy_arrow==0 and (sell_arrow==1 or sell_arrow==0) and buybreak_arrow==0 and sellbreak_arrow==1:\n",
    "                                arrow_color = 'blue'\n",
    "                            else:\n",
    "                                arrow_color = 'none'\n",
    "                            df.loc[i,'arrow_color'] = arrow_color\n",
    "                        df = df[['date','open','high','low','close','arrow_color']]\n",
    "                        return df\n",
    "                    df=super_guppy(15,df)\n",
    "                    gup=pd.DataFrame(df)\n",
    "                    def bidatrema(df,period):\n",
    "                        df['hl']=abs(df['high']-df['low'])\n",
    "                        df['hpc']=abs(df['high']-df['close'].shift())\n",
    "                        df['lpc']=abs(df['low']-df['close'].shift())\n",
    "                        df['tr']=df[['hl','hpc','lpc']].max(axis=1)\n",
    "                        df['ATR']=pd.DataFrame.ewm(df[\"tr\"], span=period,min_periods=period).mean()\n",
    "                        df.drop([\"hl\",\"hpc\",\"lpc\",\"tr\"],axis = 1 , inplace =True)\n",
    "                    bidatrema(gup,14)\n",
    "                    print(\" \\n \\t \\t \\t \\t  ZERODHA GUPPY BOT \")\n",
    "                    print(\" \\t \\t \\t \\n Current Colour on this token is \" , gup.iloc[-1,5])\n",
    "                    now_utc = datetime.now(timezone('UTC'))\n",
    "                    now_asia = now_utc.astimezone(timezone('Asia/Kolkata'))\n",
    "                    now_asia = now_asia.strftime(\"%Y-%m-%d _ %H:%M:%S \")\n",
    "                    klp1=now_asia\n",
    "                    prog_starts.append(klp1)\n",
    "                    print(\"\\n \")\n",
    "                    print(\"Zerodha GUPPY BOT start Time             \"  , prog_starts[0])\n",
    "                    print(\"\\n \")\n",
    "                    print(\"BOT working succeesfully on time:        \"  , now_asia )\n",
    "                    print(\"\\n \")\n",
    "                    print(\"Trading symbol is\",ttradingsymbol,\"Token is\",ttoken,\"Exchange is\",eexchange,\"and product type is\",productt,\"Quantity is\",qu,\"time frame for Historical Data is\",time_frame,\"Starting and Ending Date of Historical Data is\",sdate,todate)\n",
    "                    colourstill.append(gup.iloc[-1,5])\n",
    "                    print(\"\\n \")\n",
    "                    print(\"\\n \")\n",
    "                    if 0 in counter_start:\n",
    "                        if \"green\" in  gup.iloc[-1,5]:\n",
    "                            counter_start.remove(0)\n",
    "                            counter_start.append(1)\n",
    "                        else:\n",
    "                            pass\n",
    "                    if 1 in counter_start:\n",
    "                        print(\" BOT STARTED WITH GREEN ENTRY \")\n",
    "                        if \"blank\" in gup.iloc[-1,5]:\n",
    "                            print(\" Nothing Done BUT BOT started no candel colour occur \")\n",
    "                        if \"green\" in gup.iloc[-1,5]:\n",
    "                            if 0 in counter:\n",
    "                                #BUY X amount                   #-------------------------------------------------------- (A)\n",
    "                                quant=qu\n",
    "                                cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                lim_price=cur_high+buy_add\n",
    "                                print(\"Congrats ! No1 Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"A\")\n",
    "                                kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"G1\") \n",
    "                                linkedlist_1.insert(0,kite_drop)\n",
    "                                counter.remove(0)\n",
    "                                counter.append(1)\n",
    "\n",
    "                        if \"blue\" in gup.iloc[-1,5]:\n",
    "                            if 1 in counter:\n",
    "                                if 10 in counter:\n",
    "                                    print(\"Blue Comes checking blue condition @ is previous green executed or not ?\") # (A)\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:   \n",
    "                                        print(\"ORDER COMPLETED and now SELL x/2\" )\n",
    "                                        quant=int(qu/2)\n",
    "                                        stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                        triggerprice_sell=stoploss_sell-sell_add\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"Z\")\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"Z\")\n",
    "                                        print(\"No2 BLUE Sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell, \"quantity is\",quant)\n",
    "                                        linkedlist_2.insert(0,kite_drop)\n",
    "                                        counter.remove(10) # -------------------------- ( Z )\n",
    "                                        bluez.append(0)\n",
    "                                    else:\n",
    "                                        print(\" BUY not executed  \")\n",
    "                        if \"red\" in gup.iloc[-1,5]:\n",
    "                            if 1 in counter:                                              \n",
    "                                print(\"checking previous green executed or not \") \n",
    "                                update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                match_in_int=int(match_in)\n",
    "                                print(\"checking executed or not condition \")\n",
    "                                if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:   \n",
    "                                    print(\"ORDER COMPLETED and now SELL x/2\" )\n",
    "                                    quant=int(2*qu)\n",
    "                                    stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                    triggerprice_sell=stoploss_sell-sell_add\n",
    "                                    #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"B\")\n",
    "                                    kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"B\")\n",
    "                                    print(\"No3 RED Sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell, \"quantity is\",quant)\n",
    "                                    linkedlist_1.insert(0,kite_drop)\n",
    "                                    counter.remove(1)\n",
    "                                    counter.append(2)\n",
    "                                    redb.append(0)                                 # ------------------------ ( B )\n",
    "                                else:\n",
    "                                    print(\"BLUE bid not complete now canceled bule bid and place fresh sell of x amount\")\n",
    "                                    bid_not_ex=int(linkedlist_1[0])\n",
    "                                    print(\"SL Cancel Order cancelled and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                    stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                    triggerprice_sell=stoploss_sell-5\n",
    "                                    #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=qu,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"C\")\n",
    "                                    kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=qu,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"C\")\n",
    "                                    print(\"No1 C fresh start Sell Stoploss order placed\", \"quantity is\",qu ,\"and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell)\n",
    "                                    linkedlist_3.insert(0,kite_drop)     \n",
    "                                    counter.remove(1)\n",
    "                                    counter.append(2)     #  ------------ -------------- ( C )\n",
    "                                    redc.append(0) \n",
    "                                               #       *********************** checking condition *********************\n",
    "                        if 0 in bluez: \n",
    "                            if 2 in counter:\n",
    "                                if 0 in checkfirst:\n",
    "                                    print(\" RED placed and now checking RED executed or not condition \")\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        print(\" RED executed \")\n",
    "                                        print(\" Now checking  BLUE executed or not\")\n",
    "                                        update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                        match_in,=update_reverse[update_reverse.order_id==linkedlist_2[0]].index \n",
    "                                        match_in_int=int(match_in)\n",
    "                                        if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                            print(\" yes BLUE executed \")\n",
    "                                            print(\" BOTH blue and RED executed and now placig order qu/2 \")\n",
    "                                            quant=int(qu/2)\n",
    "                                            stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                            triggerprice_sell=stoploss_sell-sell_add\n",
    "                                            kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"BZ\")\n",
    "                                            print(\"Z and B both executed and market order placed\", \"quantity is\",quant)\n",
    "                                        else:\n",
    "                                            print(\"Z not executed \")\n",
    "                                            bid_not_ex=int(linkedlist_2[0])\n",
    "                                            print(\" blue Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                    else:\n",
    "                                        pass\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                                                   #  *************** comming from back ****************   \n",
    "                        if 0 in count_sectime:\n",
    "                            if 2 in counnter:\n",
    "                                update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                match_in_int=int(match_in)\n",
    "                                print(\"checking executed or not condition \")\n",
    "                                if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_2[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu/2)\n",
    "                                        stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                        triggerprice_sell=stoploss_sell-sell_add\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"BZ\")\n",
    "                                        print(\"both executed and market order placed comming from back again\", \"quantity is\",quant)\n",
    "                                        count_sectime.remove(1)\n",
    "                                    else:\n",
    "                                        print(\"Z not executed \")\n",
    "                                        bid_not_ex=int(linkedlist_2[0])\n",
    "                                        print(\" blue Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        count_sectime.remove(1)\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if \"aqua\" in gup.iloc[-1,5]:\n",
    "                            if 2 in counter:\n",
    "                                if 0 in aqua1:\n",
    "                                    if 0 in redb:\n",
    "                                        update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                        match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                        match_in_int=int(match_in)\n",
    "                                        print(\"checking executed or not condition \")\n",
    "                                        if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                            quant=int(qu/2)\n",
    "                                            cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                            lim_price=cur_high+buy_add\n",
    "                                            print(\"Congrats ! Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                            kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"F\") \n",
    "                                            print(\"in aqua and one BUY LIMIT oreder placed \",  \"quantity is\",quant)\n",
    "                                            linkedlist_3.append(0,kite_drop)                \n",
    "                                            aqua1.remove(0)          \n",
    "                                            aqua1.append(1)    #------------------------------ ( D )\n",
    "                                        else:\n",
    "                                            pass\n",
    "                                    if 0 in redc:\n",
    "                                        update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                        match_in,=update_reverse[update_reverse.order_id==linkedlist_3[0]].index \n",
    "                                        match_in_int=int(match_in)\n",
    "                                        print(\"checking executed or not condition \")\n",
    "                                        if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                            quant=int(qu/2)\n",
    "                                            cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                            lim_price=cur_high+buy_add\n",
    "                                            print(\"Congrats ! E , No1 Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                            #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"E\")\n",
    "                                            kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"E\") \n",
    "                                            linkedlist_2.insert(0,kite_drop)            \n",
    "                                            aqua1.remove(0)\n",
    "                                            aqua1.append(2)              #------------------------ ( E )\n",
    "                                        else:\n",
    "                                            pass\n",
    "                                    else:\n",
    "                                        pass\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if \"green\" in gup.iloc[-1,5]:\n",
    "                            if 2 in counter:\n",
    "                                # (  PART B ) \n",
    "                                if 0 in redb:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu*2)\n",
    "                                        cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                        lim_price=cur_high+buy_add\n",
    "                                        print(\"Congrats ! F Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"F\")\n",
    "                                        kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"F\") \n",
    "                                        linkedlist_1.insert(0,kite_drop)\n",
    "                                        counter.remove(2)\n",
    "                                        counter.append(3)\n",
    "                                        counter.append(1)\n",
    "                                        redb.remove(0)             # ---------------------------( F )\n",
    "                                        checkfirst.append(0)\n",
    "                                        counter.append(10)\n",
    "                                        bluein.append(0)\n",
    "                                    else:\n",
    "                                        bid_not_ex=int(linkedlist_1[0])\n",
    "                                        print(\" blue Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        print(\"now waiting for red again\")\n",
    "                                        linkedlist_1[0]=linkedlist_1[-1]\n",
    "                                        counter.remove(2)\n",
    "                                        counter.append(1)                                   \n",
    "                                        redb.remove(0)                      \n",
    "                                        checkfirst.append(0)\n",
    "                                        counter.append(10)\n",
    "                                # (  PART B )\n",
    "                                if 0 in redc:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_3[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu*2)\n",
    "                                        cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                        lim_price=cur_high+buy_add\n",
    "                                        print(\"Congrats ! G Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"G\")\n",
    "                                        kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"G\") \n",
    "                                        linkedlist_1.insert(0,kite_drop) \n",
    "                                        counter.remove(2)\n",
    "                                        counter.append(4)\n",
    "                                        counter.append(1)\n",
    "                                        redc.remove(0)\n",
    "                                        checkfirst.append(0)       #  ------------------------(  G )\n",
    "                                        counter.append(10)\n",
    "                                        bluein.append(0)\n",
    "                                    else:\n",
    "                                        bid_not_ex=int(linkedlist_3[0])\n",
    "                                        print(\" blue Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        print(\"now waiting for red again\")\n",
    "                                        counter.remove(2)\n",
    "                                        counter.append(1)\n",
    "                                        redc.remove(0)\n",
    "                                        checkfirst.append(0)\n",
    "                                        counter.append(10)  \n",
    "                            else:\n",
    "                                pass\n",
    "                        #  *************** checking condition 2nd time *************\n",
    "                        if 3 in counter:\n",
    "                            if 1 in aqua1:\n",
    "                                update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                match_in_int=int(match_in)\n",
    "                                print(\"checking executed or not condition \")\n",
    "                                if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_3[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu/2)\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"2Chk\")\n",
    "                                        print(\"both executed and market order placed comming from back again B and Z\")\n",
    "                                        aqua1.remove(1)\n",
    "                                    else:\n",
    "                                        print(\"not executed \")\n",
    "                                        bid_not_ex=int(linkedlist_3[0])\n",
    "                                        print(\" blue Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        aqua1.remove(1)\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if 4 in counter:\n",
    "                            if 2 in aqua1:\n",
    "                                update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                match_in_int=int(match_in)\n",
    "                                print(\"checking executed or not condition \")\n",
    "                                if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_2[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu/2)\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"2BZ\")\n",
    "                                        print(\" G and E !both executed and market order placed comming from back again\", \"quantity is\",quant)\n",
    "                                        aqua1.remove(2)\n",
    "                                    else:\n",
    "                                        print(\"not executed \")\n",
    "                                        bid_not_ex=int(linkedlist_2[0])\n",
    "                                        print(\" blue Cancel and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        aqua1.remove(2)\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if \"blue\" in  gup.iloc[-1,5]:\n",
    "                            if 3 in counter:\n",
    "                                if 0 in bluein:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        print(\"ORDER COMPLETED and now SELL x/2\" )\n",
    "                                        quant=int(qu/2)\n",
    "                                        stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                        triggerprice_sell=stoploss_sell-sell_add\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"H\")\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"H\")\n",
    "                                        print( \"quantity is\",quant,\" H blue Sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell)\n",
    "                                        linkedlist_2.insert(0,kite_drop)\n",
    "                                        blue_2F.append(1)                                       \n",
    "                                        bluein.remove(0)\n",
    "                                        bluez.append(0)\n",
    "                                        counter.remove(3)              # -------------------------- ( H )\n",
    "                                        counter.append(1)\n",
    "                                        count_sectime.append(1)\n",
    "                                    else:\n",
    "                                        pass\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if \"blue\" in  gup.iloc[-1,5]:\n",
    "                            if 4 in counter:\n",
    "                                if 0 in bluein:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        print(\"ORDER COMPLETED and now SELL x/2\" )\n",
    "                                        quant=int(qu/2)\n",
    "                                        stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                        triggerprice_sell=stoploss_sell-sell_add\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"I\")\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"I\")\n",
    "                                        print( \"quantity is\",quant,\"I blue Sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell)\n",
    "                                        linkedlist_2.insert(0,kite_drop)\n",
    "                                        blue_2G.append(1)                   \n",
    "                                        bluein.remove(0)           #----------------------- ( I )\n",
    "                                        bluez.append(0)\n",
    "                                        counter.remove(3)\n",
    "                                        counter.append(1)\n",
    "                                        count_sectime.append(1)\n",
    "                                    else:\n",
    "                                        pass\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        else:\n",
    "                            pass\n",
    "                    print(\"Colours Till Now\")\n",
    "                    print(colourstill)\n",
    "                    #display(pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"transaction_type\",\"status\",\"order_id\",\"quantity\",\"order_type\",\"exchange_update_timestamp\",'tag',\"quantity\"]].tail(10))\n",
    "        ashibb()\n",
    "    if \"SELL\"==without or \"sell\"==without:\n",
    "        print(\" SELL BOT STARTED ! \")\n",
    "        counter_start=[0]\n",
    "        linkedlist_1=[]       \n",
    "        linkedlist_2=[]      \n",
    "        linkedlist_3=[]      \n",
    "        counter=[0,10]      \n",
    "        checkfirst=[0]      \n",
    "        redb=[]             \n",
    "        bluez=[]            \n",
    "        aqua1=[0]           \n",
    "        bluein=[]           \n",
    "        blue_2F=[]          \n",
    "        blue_2G=[]          \n",
    "        count_sectime=[]\n",
    "        redc=[]\n",
    "        colourstill=[]\n",
    "        prog_starts=[]\n",
    "        #Variables\n",
    "        lst_candle=[]\n",
    "        lst_heikin_nor=[]\n",
    "        lst_heikin=[]\n",
    "        lst_cand=[]\n",
    "        lst_c=[]\n",
    "        countstart=0\n",
    "        #programe start\n",
    "        def ashis():\n",
    "            while(True):\n",
    "                km=datetime.now().minute\n",
    "                ks=datetime.now().second\n",
    "                if km%1==0 and ks==1:\n",
    "                    clear_output(wait=True)  \n",
    "                    now_utc = datetime.now(timezone('UTC'))\n",
    "                    now_asia = now_utc.astimezone(timezone('Asia/Kolkata'))\n",
    "                    now_asia = now_asia.strftime(\"%S \")\n",
    "                    klp1=now_asia\n",
    "                    #df=kite.historical_data(140033,sdate,todate,time_frame,0)\n",
    "                    dff=kite.historical_data(ttoken,sdate,todate,time_frame,0)\n",
    "                    dfw=pd.DataFrame(dff)\n",
    "                    df=pd.DataFrame(dfw[['date','open','high','low','close']])\n",
    "                    slow_ema = [3,5,7,9,11,13,15,17,19,21,23]\n",
    "                    fast_ema = [25,28,31,34,37,40,43,46,49,52,55,58,61,64,67,70,200]\n",
    "                    def EMA(df, base, target, period, alpha=False):\n",
    "                        con = pd.concat([df[:period][base].rolling(window=period).mean(), df[period:][base]])\n",
    "                        if (alpha == True):\n",
    "                            # (1 - alpha) * previous_val + alpha * current_val where alpha = 1 / period\n",
    "                            df[target] = con.ewm(alpha=1 / period, adjust=False).mean()\n",
    "                        else:\n",
    "                            # ((current_val - previous_val) * coeff) + previous_val where coeff = 2 / (period + 1)\n",
    "                            df[target] = con.ewm(span=period, adjust=False).mean()\n",
    "                        df.fillna(0,inplace = True)\n",
    "                    #     return df\n",
    "                    for j in slow_ema:\n",
    "                        val = \"ema\"+\"_\"+str(j)\n",
    "                        EMA(df,\"close\",val,j)\n",
    "                    for k in fast_ema:\n",
    "                        val = \"ema\"+\"_\"+str(k)\n",
    "                        EMA(df,\"close\",val,k)\n",
    "                    def super_guppy(interval,df,anchor=0):\n",
    "                    #     df['buy'] = 0\n",
    "                    #     df['sell'] = 0\n",
    "                    #     df['buybreak'] = 0\n",
    "                    #     df['sellbreak'] = 0\n",
    "                        anchor = 0\n",
    "                        ShowBreak = True\n",
    "                        ShowSwing = True\n",
    "                        ShowCon = False\n",
    "                        uOCCswing = False\n",
    "                        Lookback = 6\n",
    "                        emaFilter = False\n",
    "                        mult = 0\n",
    "                        buybreak = 0\n",
    "                        sellbreak = 0\n",
    "                        buy_barssince_var = 0\n",
    "                        sell_barssince_var = 0\n",
    "                        buybreak_barssince_var = 0\n",
    "                        sellbreak_barssince_var = 0\n",
    "                        barssince_lst = list()\n",
    "                        barssince_var = 0\n",
    "                        bar_count_var = 0\n",
    "                        buy1 = list()\n",
    "                        sell1 = list()\n",
    "                        buy2 = list()\n",
    "                        sell2 = list()\n",
    "                        buybreak1 = list()\n",
    "                        sellbreak1 = list()\n",
    "                        def barssince(b,barssince_var):\n",
    "                            barssince_lst = []\n",
    "                            barssince_var = 0 \n",
    "                            new_var = len(b)\n",
    "                            for i in b[::-1]:\n",
    "                                if i == 1:\n",
    "                                    break\n",
    "                                barssince_lst.append(i)\n",
    "                            barssince_var = len(barssince_lst)\n",
    "                            return barssince_var\n",
    "                            barssince_lst.clear()\n",
    "                        #isIntraday\n",
    "                        if interval < 1441 :\n",
    "                            if (anchor==0 or interval <= 0 or interval >= anchor or anchor > 1441 ):\n",
    "                                mult = 1\n",
    "                            else:\n",
    "                                if round(anchor/interval) > 1:\n",
    "                                    mult = round(anchor/interval)\n",
    "                                else:\n",
    "                                    mult = 1\n",
    "                        else:\n",
    "                            mult = 1\n",
    "                        #isIntraday Not\n",
    "                        if interval > 1441:\n",
    "                            if (anchor==0 or interval <= 0 or interval >= anchor or anchor < 52 ):\n",
    "                                mult = mult\n",
    "                            else:\n",
    "                                if round(anchor/interval) > 1:\n",
    "                                    mult = round(anchor/interval)\n",
    "                                else:\n",
    "                                    mult = 1\n",
    "                        else:\n",
    "                            mult = mult\n",
    "                        mult = 1\n",
    "                        for i in range(len(df)):\n",
    "                            emaF1 = df.loc[i,'ema_3']\n",
    "                            emaF2 = df.loc[i,'ema_5']\n",
    "                            emaF3 = df.loc[i,'ema_7']\n",
    "                            emaF4 = df.loc[i,'ema_9']\n",
    "                            emaF5 = df.loc[i,'ema_11']\n",
    "                            emaF6 = df.loc[i,'ema_13']\n",
    "                            emaF7 = df.loc[i,'ema_15']\n",
    "                            emaF8 = df.loc[i,'ema_17']\n",
    "                            emaF9 = df.loc[i,'ema_19']\n",
    "                            emaF10 = df.loc[i,'ema_21']\n",
    "                            emaF11 = df.loc[i,'ema_23']\n",
    "                            emaS1 = df.loc[i,'ema_25']\n",
    "                            emaS2 = df.loc[i,'ema_28']\n",
    "                            emaS3 = df.loc[i,'ema_31']\n",
    "                            emaS4 = df.loc[i,'ema_34']\n",
    "                            emaS5 = df.loc[i,'ema_37']\n",
    "                            emaS6 = df.loc[i,'ema_40']\n",
    "                            emaS7 = df.loc[i,'ema_43']\n",
    "                            emaS8 = df.loc[i,'ema_46']\n",
    "                            emaS9 = df.loc[i,'ema_49']\n",
    "                            emaS10 = df.loc[i,'ema_52']\n",
    "                            emaS11 = df.loc[i,'ema_55']\n",
    "                            emaS12 = df.loc[i,'ema_58']\n",
    "                            emaS13 = df.loc[i,'ema_61']\n",
    "                            emaS14 = df.loc[i,'ema_64']\n",
    "                            emaS15 = df.loc[i,'ema_67']\n",
    "                            emaS16 = df.loc[i,'ema_70']\n",
    "                            ema200 = df.loc[i,'ema_200'] \n",
    "                            emafast = (emaF1 + emaF2 + emaF3 + emaF4 + emaF5 + emaF6 + emaF7 + emaF8 + emaF9 + emaF10 + emaF11)/11\n",
    "                            emaslow = (emaS1 + emaS2 + emaS3 + emaS4 + emaS5 + emaS6 + emaS7 + emaS8 + emaS9 + emaS10 + emaS11 + emaS12 + emaS13 + emaS14 + emaS15 + emaS16)/16\n",
    "                            #Fast EMA Color Rules\n",
    "                            colfastL = (emaF1>emaF2 and emaF2>emaF3 and emaF3>emaF4 and emaF4>emaF5 and emaF5>emaF6 and emaF6>emaF7 and emaF7>emaF8 and emaF8>emaF9 and emaF9>emaF10 and emaF10>emaF11)\n",
    "                            colfastS = (emaF1<emaF2 and emaF2<emaF3 and emaF3<emaF4 and emaF4<emaF5 and emaF5<emaF6 and emaF6<emaF7 and emaF7<emaF8 and emaF8<emaF9 and emaF9<emaF10 and emaF10<emaF11)\n",
    "                            #Slow EMA Color Rules\n",
    "                            colslowL = (emaS1>emaS2 and emaS2>emaS3 and emaS3>emaS4 and emaS4>emaS5 and emaS5>emaS6 and emaS6>emaS7 and emaS7>emaS8) and (emaS8>emaS9 and emaS9>emaS10 and emaS10>emaS11 and emaS11>emaS12 and emaS12>emaS13 and emaS13>emaS14 and emaS14>emaS15 and emaS15>emaS16)\n",
    "                            colslowS = (emaS1<emaS2 and emaS2<emaS3 and emaS3<emaS4 and emaS4<emaS5 and emaS5<emaS6 and emaS6<emaS7 and emaS7<emaS8) and (emaS8<emaS9 and emaS9<emaS10 and emaS10<emaS11 and emaS11<emaS12 and emaS12<emaS13 and emaS13<emaS14 and emaS14<emaS15 and emaS15<emaS16)\n",
    "                            if  emafast > emaslow and not colslowS and colfastL and (not ShowCon or colslowL) and (not emaFilter or emafast>ema200):\n",
    "                                if int(buy1[-1]) > 0:\n",
    "                                    buy = buy1[-1] + 1\n",
    "                                else:\n",
    "                                    buy = 1\n",
    "                            else:\n",
    "                                buy = 0\n",
    "                            buy1.append(buy)\n",
    "                            if  emafast < emaslow and not colslowL and colfastS and (not ShowCon or colslowS) and (not emaFilter or emafast<ema200):\n",
    "                                if int(sell1[-1]) > 0:\n",
    "                                    sell = sell1[-1] + 1\n",
    "                                else:\n",
    "                                    sell = 1\n",
    "                            else:\n",
    "                                sell = 0\n",
    "                            sell1.append(sell)\n",
    "                            #buy\n",
    "                            if buy>1 and colfastL and (uOCCswing and ((df.loc[i-1,'close']<df.loc[i-1,'open']) and (df.loc[i,'close']>df.loc[i,'open']))):\n",
    "                                buy3 = 1\n",
    "                            else:\n",
    "                                buy3 = buy\n",
    "                            buy2.append(buy3)\n",
    "                            #sell    \n",
    "                            if sell>1 and colfastS and (uOCCswing and ((df.loc[i-1,'close']<df.loc[i-1,'open']) and (df.loc[i,'close']>df.loc[i,'open']))):\n",
    "                                sell3 = 1\n",
    "                            else:\n",
    "                                sell3 = sell\n",
    "                            sell2.append(sell3)\n",
    "                            #buybreak\n",
    "                            if emafast > emaslow and not colslowS and (not emaFilter or emafast>ema200):\n",
    "                                if buybreak1[-1] > 0:\n",
    "                                    buybreak = buybreak1[-1] + 1\n",
    "                                else:\n",
    "                                    buybreak = 1\n",
    "                            else:\n",
    "                                buybreak = 0\n",
    "                            buybreak1.append(buybreak)\n",
    "                            if emafast < emaslow and not colslowL and (not emaFilter or emafast<ema200):\n",
    "                                if sellbreak1[-1] > 0:\n",
    "                                    sellbreak = sellbreak1[-1]+1\n",
    "                                else:\n",
    "                                    sellbreak = 1\n",
    "                            else:\n",
    "                                sellbreak = 0\n",
    "                            sellbreak1.append(sellbreak)\n",
    "                            #arrow plotting\n",
    "                            #buy_arrow\n",
    "                            buy_barssince_var = barssince(buy2[:-1],barssince_var)\n",
    "                            if (ShowSwing and buy3==1)and buy_barssince_var > 6:\n",
    "                                buy_arrow = 1\n",
    "                            else:\n",
    "                                buy_arrow = 0\n",
    "                            #sell arrow\n",
    "                            sell_barssince_var = barssince(sell2[:-1],barssince_var)\n",
    "                            if ShowSwing and (sell3==1 and sell_barssince_var > 6):\n",
    "                                sell_arrow = 1\n",
    "                            else:\n",
    "                                sell_arrow = 0\n",
    "                            #buybreak_arrow\n",
    "                            buybreak_barssince_var = barssince(buybreak1[:-1],barssince_var)\n",
    "                            sellbreak_barssince_var = barssince(sellbreak1[:-1],barssince_var)\n",
    "\n",
    "                            if ShowBreak and buybreak==1 and (sellbreak_barssince_var>Lookback) and (buybreak_barssince_var>Lookback):\n",
    "                                buybreak_arrow = 1\n",
    "                            else:\n",
    "                                buybreak_arrow = 0\n",
    "                            #sellbreak_arrow\n",
    "                            if ShowBreak and sellbreak==1 and (buybreak_barssince_var>Lookback) and (sellbreak_barssince_var>Lookback):\n",
    "                                sellbreak_arrow = 1\n",
    "                            else:\n",
    "                                sellbreak_arrow = 0\n",
    "                            if buy_arrow==1 and sell_arrow==0 and buybreak_arrow==0 and sellbreak_arrow==0:\n",
    "                                arrow_color = 'green'\n",
    "                            elif buy_arrow==0 and sell_arrow==1 and buybreak_arrow==0 and sellbreak_arrow==0:\n",
    "                                arrow_color = 'red'\n",
    "                            elif sell_arrow==0 and (buy_arrow==0 or buy_arrow==1) and buybreak_arrow==1 and sellbreak_arrow==0:\n",
    "                                arrow_color = 'aqua'\n",
    "                            elif buy_arrow==0 and (sell_arrow==1 or sell_arrow==0) and buybreak_arrow==0 and sellbreak_arrow==1:\n",
    "                                arrow_color = 'blue'\n",
    "                            else:\n",
    "                                arrow_color = 'none'\n",
    "                            df.loc[i,'arrow_color'] = arrow_color\n",
    "                        df = df[['date','open','high','low','close','arrow_color']]\n",
    "                        return df\n",
    "                    df=super_guppy(15,df)\n",
    "                    gup=pd.DataFrame(df)\n",
    "                    def bidatrema(df,period):\n",
    "                        df['hl']=abs(df['high']-df['low'])\n",
    "                        df['hpc']=abs(df['high']-df['close'].shift())\n",
    "                        df['lpc']=abs(df['low']-df['close'].shift())\n",
    "                        df['tr']=df[['hl','hpc','lpc']].max(axis=1)\n",
    "                        df['ATR']=pd.DataFrame.ewm(df[\"tr\"], span=period,min_periods=period).mean()\n",
    "                        df.drop([\"hl\",\"hpc\",\"lpc\",\"tr\"],axis = 1 , inplace =True)\n",
    "                    bidatrema(gup,14)\n",
    "                    print(\" \\n \\t \\t \\t \\t  ZERODHA GUPPY BOT \")\n",
    "                    print(\" \\t \\t \\t \\n Current Colour on this token is \" , gup.iloc[-1,5])\n",
    "                    now_utc = datetime.now(timezone('UTC'))\n",
    "                    now_asia = now_utc.astimezone(timezone('Asia/Kolkata'))\n",
    "                    now_asia = now_asia.strftime(\"%Y-%m-%d _ %H:%M:%S \")\n",
    "                    klp1=now_asia\n",
    "                    prog_starts.append(klp1)\n",
    "                    print(\"\\n \")\n",
    "                    print(\"Zerodha GUPPY BOT start Time             \"  , prog_starts[0])\n",
    "                    print(\"\\n \")\n",
    "                    print(\"BOT working succeesfully on time:        \"  , now_asia )\n",
    "                    print(\"\\n \")\n",
    "                    print(\"Trading symbol is\",ttradingsymbol,\"Token is\",ttoken,\"Exchange is\",eexchange,\"and product type is\",productt,\"Quantity is\",qu,\"time frame for Historical Data is\",time_frame,\"Starting and Ending Date of Historical Data is\",sdate,todate)\n",
    "                    \n",
    "                    colourstill.append(gup.iloc[-1,5])\n",
    "                    print(\"\\n \")\n",
    "                    print(\"\\n \")\n",
    "                    if 0 in counter_start:\n",
    "                        if \"red\" in gup.iloc[-1,5]:\n",
    "                            counter_start.remove(0)\n",
    "                            counter_start.append(2)\n",
    "                        else:\n",
    "                            pass\n",
    "                    if 2 in counter_start:\n",
    "                        print(\" BOT STARTED WITH RED ' SELL' ENTRY \")\n",
    "                        if \"blank\" in gup.iloc[-1,5]:\n",
    "                            print(\" Nothing Done BUT BOT started no candel colour occur \")\n",
    "                        if \"red\" in gup.iloc[-1,5]:\n",
    "                            if 0 in counter:\n",
    "                                #SELl X amount                   #-------------------------------------------------------- (A)\n",
    "                                quant=qu\n",
    "                                stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                triggerprice_sell=stoploss_sell-sell_add\n",
    "                                #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"A\")\n",
    "                                kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"A\")\n",
    "                                print(\"red sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell, \"quantity is\",quant)\n",
    "                                linkedlist_1.insert(0,kite_drop)\n",
    "                                counter.remove(0)\n",
    "                                counter.append(1)\n",
    "                        if \"aqua\" in gup.iloc[-1,5]:\n",
    "                            if 1 in counter:\n",
    "                                if 10 in counter:\n",
    "                                    print(\"aqua Comes checking blue condition @ is previous green executed or not ?\") # (A)\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:   \n",
    "                                        print(\"ORDER COMPLETED and now buy x/2\" )\n",
    "                                        quant=int(qu/2)\n",
    "                                        cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                        lim_price=cur_high+buy_add\n",
    "                                        print(\"Congrats ! Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"Z\")\n",
    "                                        kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"Z\")\n",
    "                                        linkedlist_2.insert(0,kite_drop)\n",
    "                                        counter.remove(10) # -------------------------- ( Z )\n",
    "                                        bluez.append(0)\n",
    "                                    else:\n",
    "                                        print(\" sell not executed  \")\n",
    "                        if \"green\" in gup.iloc[-1,5]:\n",
    "                            if 1 in counter:                                              \n",
    "                                print(\"checking previous green executed or not \") \n",
    "                                update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                match_in_int=int(match_in)\n",
    "                                print(\"checking executed or not condition \")\n",
    "                                if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:   \n",
    "                                    print(\"ORDER COMPLETED and now BUY x/2\" )\n",
    "                                    quant=int(2*qu)\n",
    "                                    cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                    lim_price=cur_high+buy_add\n",
    "                                    print(\"Congrats ! No1 Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                    #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"B\")\n",
    "                                    kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"B\")\n",
    "                                    linkedlist_1.insert(0,kite_drop)\n",
    "                                    counter.remove(1)\n",
    "                                    counter.append(2)\n",
    "                                    redb.append(0)                                 # ------------------------ ( B )\n",
    "                                else:\n",
    "                                    print(\"aqua bid not complete now canceled aqua bid and place fresh BUY of x amount\")\n",
    "                                    bid_not_ex=int(linkedlist_1[0])\n",
    "                                    print(\"SL Cancel Order cancelled and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                    cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                    lim_price=cur_high+3 \n",
    "                                    print(\"Congrats ! Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                    #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"C\")\n",
    "                                    kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"C\")\n",
    "                                    linkedlist_3.insert(0,kite_drop)     #  ------------ -------------- ( C )\n",
    "                                    counter.remove(1)\n",
    "                                    counter.append(2) \n",
    "                                    redc.append(0)\n",
    "                                                    #       *********************** checking condition *********************\n",
    "                        if 0 in bluez:\n",
    "                            if 2 in counter:\n",
    "                                if 0 in checkfirst:\n",
    "                                    print(\" green placed and now checking RED executed or not condition \")\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        print(\" green executed \")\n",
    "                                        print(\" Now checkingaqua executed or not\")\n",
    "                                        update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                        match_in,=update_reverse[update_reverse.order_id==linkedlist_2[0]].index \n",
    "                                        match_in_int=int(match_in)\n",
    "                                        if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                            print(\" yes BLUE executed \")\n",
    "                                            print(\" BOTH aqua and green executed and now placig order qu/2 \")\n",
    "                                            quant=int(qu/2)\n",
    "                                            kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"BZ\")\n",
    "                                            print(\"Z and B both executed and market order placed\", \"quantity is\",quant)\n",
    "                                        else:\n",
    "                                            print(\"Z not executed \")\n",
    "                                            bid_not_ex=int(linkedlist_2[0])\n",
    "                                            print(\" aqua Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                    else:\n",
    "                                        pass\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                                                        #  *************** comming from back ****************  \n",
    "                        if 0 in count_sectime:\n",
    "                            if 2 in counnter:\n",
    "                                update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                match_in_int=int(match_in)\n",
    "                                print(\"checking executed or not condition \")\n",
    "                                if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_2[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu/2)\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"BZ\")\n",
    "                                        print(\"both executed and market order placed comming from back again\", \"quantity is\",quant)\n",
    "                                        count_sectime.remove(1)\n",
    "                                    else:\n",
    "                                        print(\"Z not executed \")\n",
    "                                        bid_not_ex=int(linkedlist_2[0])\n",
    "                                        print(\" aqua Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        count_sectime.remove(1)\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if \"blue\" in gup.iloc[-1,5]:\n",
    "                            if 2 in counter:\n",
    "                                if 0 in aqua1:\n",
    "                                    if 0 in redb:\n",
    "                                        update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                        match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                        match_in_int=int(match_in)\n",
    "                                        print(\"checking executed or not condition \")\n",
    "                                        if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                            # ( NOW SELL X/2 )         #------------------------------ ( D )\n",
    "                                            quant=int(qu/2)\n",
    "                                            stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                            triggerprice_sell=stoploss_sell-sell_add\n",
    "                                            #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"D\")\n",
    "                                            kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"D\")\n",
    "                                            print(\"Sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell, \"quantity is\",quant)\n",
    "                                            linkedlist_3.append(0,kite_drop)                \n",
    "                                            aqua1.remove(0)          \n",
    "                                            aqua1.append(1)\n",
    "                                        else:\n",
    "                                            pass\n",
    "                                    if 0 in redc:\n",
    "                                        update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                        match_in,=update_reverse[update_reverse.order_id==linkedlist_3[0]].index \n",
    "                                        match_in_int=int(match_in)\n",
    "                                        print(\"checking executed or not condition \")\n",
    "                                        if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                            quant=int(qu/2)\n",
    "                                            stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                            triggerprice_sell=stoploss_sell-sell_add\n",
    "                                            #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"E\")\n",
    "                                            kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"E\")\n",
    "                                            print(\" aqua Sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell, \"quantity is\",quant)\n",
    "                                            linkedlist_2.insert(0,kite_drop)            \n",
    "                                            aqua1.remove(0)\n",
    "                                            aqua1.append(2)              #------------------------ ( E )\n",
    "                                        else:\n",
    "                                            pass\n",
    "                                    else:\n",
    "                                        pass\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if \"red\" in gup.iloc[-1,5]:\n",
    "                            if 2 in counter:\n",
    "                                # (  PART B ) \n",
    "                                if 0 in redb:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu*2)\n",
    "                                        stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                        triggerprice_sell=stoploss_sell-sell_add\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"F\")\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"F\")\n",
    "                                        print(\" Sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell, \"quantity is\",quant)\n",
    "                                        linkedlist_1.insert(0,kite_drop)\n",
    "                                        counter.remove(2)\n",
    "                                        counter.append(3)\n",
    "                                        counter.append(1)        # #----------------------- ( F )\n",
    "                                        redb.remove(0)\n",
    "                                        checkfirst.append(0)\n",
    "                                        counter.append(10)\n",
    "                                        bluein.append(0)\n",
    "                                    else:\n",
    "                                        bid_not_ex=int(linkedlist_1[0])\n",
    "                                        print(\" aqua Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        print(\"now waiting for green again\")\n",
    "                                        linkedlist_1[0]=linkedlist_1[-1]\n",
    "                                        counter.remove(2)\n",
    "                                        counter.append(1)                                   \n",
    "                                        redb.remove(0)                      \n",
    "                                        checkfirst.append(0)\n",
    "                                        counter.append(10)\n",
    "                                # (  PART B )\n",
    "                                if 0 in redc:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_3[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu*2)\n",
    "                                        stoploss_sell=int(gup.iloc[-1,3]-gup.iloc[-1,6]*.25)\n",
    "                                        triggerprice_sell=stoploss_sell-sell_add\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='SELL',product=productt,tag=\"G\")\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',stoploss= stoploss_sell,trigger_price=triggerprice_sell,transaction_type='SELL',product=productt,tag=\"G\")\n",
    "                                        print(\" aqua Sell Stoploss order placed and SL trigger price is\",triggerprice_sell,\"and stoploss is\",stoploss_sell, \"quantity is\",quant)\n",
    "                                        linkedlist_1.insert(0,kite_drop) \n",
    "                                        counter.remove(2)\n",
    "                                        counter.append(4)\n",
    "                                        counter.append(1)\n",
    "                                        redc.remove(0)\n",
    "                                        checkfirst.append(0)       #  ------------------------(  G )\n",
    "                                        counter.append(10)\n",
    "                                        bluein.append(0)\n",
    "                                    else:\n",
    "                                        bid_not_ex=int(linkedlist_3[0])\n",
    "                                        print(\" aqua Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        print(\"now waiting for green again\")\n",
    "                                        counter.remove(2)\n",
    "                                        counter.append(1)\n",
    "                                        redc.remove(0)\n",
    "                                        checkfirst.append(0)\n",
    "                                        counter.append(10)  \n",
    "                            else:\n",
    "                                pass\n",
    "                                               #   *********** checking condition 2nd time *************\n",
    "                        if 3 in counter:\n",
    "                            if 1 in aqua1:\n",
    "                                update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                match_in_int=int(match_in)\n",
    "                                print(\"checking executed or not condition \")\n",
    "                                if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_3[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu/2)\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"2Chk\")\n",
    "                                        print(\"both executed and market order placed comming from back again B and Z\")\n",
    "                                        aqua1.remove(1)\n",
    "                                    else:\n",
    "                                        print(\"not executed \")\n",
    "                                        bid_not_ex=int(linkedlist_3[0])\n",
    "                                        print(\" aqua Cancel (Z) and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        aqua1.remove(1)\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if 4 in counter:\n",
    "                            if 2 in aqua1:\n",
    "                                update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                match_in_int=int(match_in)\n",
    "                                print(\"checking executed or not condition \")\n",
    "                                if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_2[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        quant=int(qu/2)\n",
    "                                        kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"2BZ\")\n",
    "                                        print(\" G and E !both executed and market order placed comming from back again\", \"quantity is\",quant)\n",
    "                                        aqua1.remove(2)\n",
    "                                    else:\n",
    "                                        print(\"not executed \")\n",
    "                                        bid_not_ex=int(linkedlist_2[0])\n",
    "                                        print(\" aqua Cancel and order id\",kite.cancel_order(\"regular\",order_id=bid_not_ex,parent_order_id=None))\n",
    "                                        aqua1.remove(2)\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if \"aqua\" in  gup.iloc[-1,5]:\n",
    "                            if 3 in counter:\n",
    "                                if 0 in bluein:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        print(\"ORDER COMPLETED and now SELL x/2\" )\n",
    "                                        quant=int(qu/2)\n",
    "                                        cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                        lim_price=cur_high+buy_add\n",
    "                                        print(\"Congrats !  Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"H\")\n",
    "                                        kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"H\")\n",
    "                                        linkedlist_2.insert(0,kite_drop)\n",
    "                                        blue_2F.append(1)                                       \n",
    "                                        bluein.remove(0)\n",
    "                                        bluez.append(0)\n",
    "                                        counter.remove(3)              # -------------------------- ( H )\n",
    "                                        counter.append(1)\n",
    "                                        count_sectime.append(1)\n",
    "                                    else:\n",
    "                                        pass\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        if \"aqua\" in  gup.iloc[-1,5]:\n",
    "                            if 4 in counter:\n",
    "                                if 0 in bluein:\n",
    "                                    update_reverse=pd.DataFrame(kite.orders())[[\"tradingsymbol\",\"status\",\"order_id\",\"quantity\"]]\n",
    "                                    match_in,=update_reverse[update_reverse.order_id==linkedlist_1[0]].index \n",
    "                                    match_in_int=int(match_in)\n",
    "                                    print(\"checking executed or not condition \")\n",
    "                                    if \"COMPLETE\" in update_reverse.loc[match_in_int,\"status\"]:\n",
    "                                        print(\"ORDER COMPLETED and now SELL x/2\" )\n",
    "                                        quant=int(qu/2)\n",
    "                                        cur_high=int(gup.iloc[-1,2]+(gup.iloc[-1,6]*.25))\n",
    "                                        lim_price=cur_high+buy_add\n",
    "                                        print(\"Congrats ! Buy Limit Order placed Price is\",lim_price,\"and trigger_price is\",cur_high, \"quantity is\",quant)\n",
    "                                        #kite_drop=kite.place_order(variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='MARKET',transaction_type='BUY',product=productt,tag=\"I\")\n",
    "                                        kite_drop=kite.place_order( variety=\"regular\",tradingsymbol=ttradingsymbol,quantity=quant,exchange=eexchange,order_type='SL',price=lim_price ,trigger_price=cur_high,transaction_type='BUY',product=productt,tag=\"I\")\n",
    "                                        linkedlist_2.insert(0,kite_drop)\n",
    "                                        blue_2G.append(1)                   \n",
    "                                        bluein.remove(0)           #----------------------- ( I )\n",
    "                                        bluez.append(0)\n",
    "                                        counter.remove(3)\n",
    "                                        counter.append(1)\n",
    "                                        count_sectime.append(1)\n",
    "                                    else:\n",
    "                                        pass\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                pass\n",
    "                        else:\n",
    "                            pass \n",
    "                        print(\" Orders Till Now \")\n",
    "        ashis()\n",
    "else:\n",
    "    pass"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}

# end #