YHT_MNC_NIFTY50_7_12_2020_Equal.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.877Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "################## auto login ######################\n",
    "import login\n",
    "from login import *\n",
    "import pandas as pd\n",
    "from loguru import logger\n",
    "import pytz\n",
    "from time import sleep\n",
    "import datetime\n",
    "import json\n",
    "import pandas as pd\n",
    "# mypath = 'C:\\Users\\YOGESH\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.8_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python38\\Scripts\\trade_scripts_notes'\n",
    "logger.add(\"./logs/MNC_logs_{time}.log\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.881Z"
    }
   },
   "outputs": [],
   "source": [
    "################# Parameters #######################\n",
    "my_margin = 120000.00\n",
    "reserved_margin = 1000.00\n",
    "squareup_percent = 10.00\n",
    "################## Constants #######################\n",
    "exchange_type = kite.EXCHANGE_NSE\n",
    "available_margin_for_trades = my_margin - reserved_margin\n",
    "n50_token = 256265\n",
    "n50_symbol = 'NIFTY 50'\n",
    "days_ago=3\n",
    "prev_gapup_down_limit = 2.00"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.885Z"
    }
   },
   "outputs": [],
   "source": [
    "############# Import Old qty_df File ###############\n",
    "import os.path\n",
    "from os import path\n",
    "is_qty_df_available = path.exists('qty_df.p')\n",
    "old_qty_df = pd.DataFrame()\n",
    "if(is_qty_df_available):\n",
    "    old_qty_df = joblib.load('./qty_df.p')\n",
    "# old_qty_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.889Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "############### Get Stocks Margin Map ############\n",
    "import requests\n",
    "url = 'https://api.kite.trade/margins/equity'\n",
    "margin_data = requests.get(url, timeout=2.50)\n",
    "margin_map = json.loads(margin_data.content.decode('utf-8'))\n",
    "margin_map_df = pd.DataFrame(margin_map)\n",
    "\n",
    "############ Get N/50 Stocks List ################\n",
    "n50df = pd.read_excel('./n50.xlsx')\n",
    "n50df = n50df.loc[n50df['tradable'] == 'y']\n",
    "\n",
    "############### Merge Both Data ##################\n",
    "merged_df = pd.merge(n50df, margin_map_df, on=\"tradingsymbol\")\n",
    "merged_df['instrument_token'] = merged_df['instrument_token'].astype(int)\n",
    "merged_df['exchange_token'] = merged_df['exchange_token'].astype(int)\n",
    "# merged_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.894Z"
    }
   },
   "outputs": [],
   "source": [
    "############## Stock Margin Calucator for Bracket Order #####################\n",
    "def calc_margin(co_upper,co_lower,price,stoploss=100, transaction_type = 'sell',quantity=1):\n",
    "    '''calc_margin(co_upper,co_lower,stk_data,price,stoploss=10, transaction_type = 'sell',quantity=1)'''\n",
    "    co_lower = co_lower/100\n",
    "    co_upper = co_upper/100\n",
    "    trigger = price - (co_upper * price)\n",
    "    \n",
    "    if stoploss < trigger:\n",
    "        stoploss = trigger\n",
    "    else:\n",
    "        trigger = stoploss\n",
    "    x = 0\n",
    "    if transaction_type == 'buy':\n",
    "        x = (price - trigger) * quantity\n",
    "    else:\n",
    "        x = (trigger - price) * quantity\n",
    "        \n",
    "    y = co_lower * price * quantity\n",
    "#     margin  = x if( x > y) else y\n",
    "#     margin = margin + (margin * 0.2)\n",
    "    return y\n",
    "\n",
    "############# Get 9:15 Data ##############################################\n",
    "def get_mornign_data( inst_token, interval='5minute'):\n",
    "    '''get_mornign_data( inst_token, interval='5minute')'''\n",
    "    interval=interval\n",
    "    inst_token = inst_token\n",
    "    todaydt=datetime.date.today()\n",
    "    hud_ago=todaydt-datetime.timedelta(days=days_ago)\n",
    "    to_date=datetime.date.isoformat(todaydt)\n",
    "\n",
    "    from_date=datetime.date.isoformat(hud_ago)\n",
    "    data = kite.historical_data(inst_token, from_date, to_date, interval, continuous=False)\n",
    "    prev_close = kite.quote([inst_token])[str(inst_token)]['ohlc']['close']\n",
    "    mydata = pd.DataFrame(data)\n",
    "    today = datetime.date.today()\n",
    "#     print('Today Date : '+str(today))\n",
    "    yest_date =  mydata[-days_ago:][['date']].to_numpy()[0][0]\n",
    "    last_close =  mydata[-days_ago:][['close']].to_numpy()[0][0]\n",
    "    last_high =  mydata[-days_ago:][['high']].to_numpy()[0][0]\n",
    "    last_low =  mydata[-days_ago:][['low']].to_numpy()[0][0]\n",
    "#     print('yest_date : '+str(yest_date))\n",
    "#     print('last close : '+ str(last_close))\n",
    "#     print('last high : '+ str(last_high))\n",
    "#     print('last low : '+ str(last_low))\n",
    "\n",
    "    import pytz\n",
    "    \n",
    "    tz = pytz.timezone(\"Asia/Calcutta\")\n",
    "    \n",
    "    this_day = today.day\n",
    "    now_time = datetime.datetime.now()\n",
    "    \n",
    "    if(now_time.hour <8 ):\n",
    "        last_day = today-datetime.timedelta(days=1)\n",
    "        this_day = last_day.day\n",
    "    \n",
    "    b =tz.localize( datetime.datetime(today.year, today.month, this_day, 9, 15,0,0))\n",
    "    # today.day\n",
    "    timestamp = pd.Timestamp(b)\n",
    "    mycandle = mydata.loc[mydata['date'] == timestamp]\n",
    "    \n",
    "    buy_exit = mycandle['high'].to_numpy()[0]*((100.0+squareup_percent)/100.0)\n",
    "    sell_exit = mycandle['low'].to_numpy()[0]*((100.0-squareup_percent)/100.0)\n",
    "    \n",
    "    buy_exit = round(0.05 * round(buy_exit /0.05),2)\n",
    "    sell_exit = round(0.05 * round(sell_exit /0.05),2)\n",
    "    \n",
    "    return {'open':mycandle['open'].to_numpy()[0],\n",
    "            'high':mycandle['high'].to_numpy()[0],\n",
    "            'low':mycandle['low'].to_numpy()[0],\n",
    "            'close':mycandle['close'].to_numpy()[0],\n",
    "            'prev_close':prev_close,\n",
    "            'buy_exit':buy_exit,\n",
    "            'sell_exit':sell_exit,}\n",
    "\n",
    "########### Decide Buy/Sell ###############\n",
    "def decide_buy_sell(morning_candle):\n",
    "    direction = ''\n",
    "    if(morning_candle['open']>morning_candle['close']):\n",
    "        direction = 'sell'\n",
    "    if(morning_candle['open']<morning_candle['close']):\n",
    "        direction = 'buy'\n",
    "    return direction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.900Z"
    }
   },
   "outputs": [],
   "source": [
    "# ################ Wait Till 9:20 #####################\n",
    "############### Wait Till 9:20 #####################\n",
    "def act(x):\n",
    "    return x+10\n",
    "\n",
    "def wait_start(runTime, action):\n",
    "    startTime = datetime.time(*(map(int, runTime.split(':'))))\n",
    "    while startTime > datetime.datetime.today().time(): \n",
    "        sleep(1)\n",
    "    return action\n",
    "\n",
    "wait_start('9:20', lambda: act(100))\n",
    "\n",
    "# def act(x):\n",
    "#      return x+10\n",
    "\n",
    "# def wait_start(runTime, action):\n",
    "#      startTime = datetime.time(*(map(int, runTime.split(':'))))\n",
    "#         while startTime > datetime.datetime.today().time(): \n",
    "#             sleep(1)\n",
    "#         return action\n",
    "\n",
    "#     wait_start('9:20', lambda: act(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.904Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "################# Add Buy/Sell Direction to merged_df ############\n",
    "direction_list = []\n",
    "for i in merged_df.instrument_token.to_list():\n",
    "    this_map = get_mornign_data(i)\n",
    "    this_dir = decide_buy_sell(this_map)\n",
    "    direction_list.append({'instrument_token':i,'direction':this_dir,\n",
    "                           'morning_open':this_map['open'],\n",
    "                           'morning_high':this_map['high'],\n",
    "                           'morning_low':this_map['low'],\n",
    "                           'morning_close':this_map['close'],\n",
    "                           'prev_close':this_map['prev_close'],\n",
    "                           'buy_exit':this_map['buy_exit'],\n",
    "                           'sell_exit':this_map['sell_exit'],})\n",
    "    print(i)\n",
    "\n",
    "    \n",
    "direction_list_df = pd.DataFrame(direction_list)\n",
    "merged_df2 = pd.merge(merged_df, direction_list_df, on=\"instrument_token\")\n",
    "# merged_df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.908Z"
    }
   },
   "outputs": [],
   "source": [
    "################ Get Considered DF Comparing to N50 Direction ########## \n",
    "nifty50_morning_candle = get_mornign_data(n50_token)\n",
    "nifty_direction = decide_buy_sell(nifty50_morning_candle)\n",
    "considered_df = merged_df2.loc[merged_df2['direction'] == nifty_direction]\n",
    "# considered_df\n",
    "nifty_direction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.918Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "################### Decide Qty for Every Symbol #####################\n",
    "qty_df_list = []\n",
    "for inst in considered_df.instrument_token:\n",
    "    this_co_upper = considered_df.loc[considered_df['instrument_token'] ==\n",
    "                                      inst]['co_upper'].to_numpy()[0]\n",
    "    this_co_lower = considered_df.loc[considered_df['instrument_token'] ==\n",
    "                                      inst]['co_lower'].to_numpy()[0]\n",
    "    this_price = 1.0\n",
    "    this_sl = 1.0\n",
    "    if (nifty_direction == 'buy'):\n",
    "        this_price = considered_df.loc[considered_df['instrument_token'] ==\n",
    "                                       inst]['morning_high'].to_numpy()[0]\n",
    "        this_sl = considered_df.loc[considered_df['instrument_token'] ==\n",
    "                                    inst]['morning_low'].to_numpy()[0]\n",
    "    else:\n",
    "        this_price = considered_df.loc[considered_df['instrument_token'] ==\n",
    "                                       inst]['morning_low'].to_numpy()[0]\n",
    "        this_sl = considered_df.loc[considered_df['instrument_token'] ==\n",
    "                                    inst]['morning_high'].to_numpy()[0]\n",
    "    this_marg = calc_margin(this_co_upper,\n",
    "                            this_co_lower,\n",
    "                            this_price,\n",
    "                            stoploss=this_sl,\n",
    "                            transaction_type=nifty_direction)\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "#     remaining_weight = 100-considered_df.sum()['weight']\n",
    "#     remaining_weight_per_symbol = remaining_weight/(len(considered_df.instrument_token.to_list()))\n",
    "#     this_weight = considered_df.loc[considered_df['instrument_token'] == inst]['weight'].to_numpy()[0]\n",
    "#     this_net_weight = this_weight + remaining_weight_per_symbol\n",
    "#     weighted_margin = available_margin_for_trades * this_net_weight/100\n",
    "#     this_qty = int(weighted_margin / this_marg)\n",
    "    \n",
    "    \n",
    "    weighted_margin = available_margin_for_trades/len(considered_df.instrument_token.to_list())\n",
    "    this_qty = int(weighted_margin / this_marg)\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    this_gap_upper_limit = (considered_df.loc[considered_df['instrument_token'] ==\n",
    "                                       inst]['prev_close'].to_numpy()[0])*((100+prev_gapup_down_limit)/100.00)\n",
    "    \n",
    "    this_gap_lower_limit = (considered_df.loc[considered_df['instrument_token'] ==\n",
    "                                       inst]['prev_close'].to_numpy()[0])*((100-prev_gapup_down_limit)/100.00)\n",
    "    \n",
    "    \n",
    "    this_gap_upper_limit = round(0.05 * round(this_gap_upper_limit /0.05),2)\n",
    "    this_gap_lower_limit = round(0.05 * round(this_gap_lower_limit /0.05),2)\n",
    "    \n",
    "    qty_df_list.append({\n",
    "        'instrument_token': inst,\n",
    "        'co_bo_margin': this_marg,\n",
    "        'weighted_margin':weighted_margin,\n",
    "        'trade_qty': this_qty,\n",
    "#         'new_weight':this_net_weight,\n",
    "        'my_qty': 0,\n",
    "        'ltp': 0.0,\n",
    "        'stop_trading': False,\n",
    "        'last_updated_on': str(datetime.date.today()),\n",
    "        'order_id':111111,\n",
    "        'gap_upper_limit':this_gap_upper_limit,\n",
    "        'gap_lower_limit':this_gap_lower_limit\n",
    "    })\n",
    "\n",
    "qty_df = pd.DataFrame(qty_df_list)\n",
    "qty_df = pd.merge(considered_df, qty_df, on=\"instrument_token\")\n",
    "if(not old_qty_df.empty):\n",
    "    qty_df['stop_trading'] = old_qty_df['stop_trading']\n",
    "    qty_df['last_updated_on'] = old_qty_df['last_updated_on']\n",
    "    qty_df['order_id'] = old_qty_df['order_id']\n",
    "\n",
    "qty_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.923Z"
    }
   },
   "outputs": [],
   "source": [
    "###################### Clear Yesterday True/False ##################################\n",
    "for my_inst in qty_df.instrument_token:\n",
    "    this_last_up = str(qty_df.loc[qty_df['instrument_token'] ==\n",
    "                                                         my_inst]['last_updated_on'].to_numpy()[0]).split('-')[2]\n",
    "    this_last_up = int(this_last_up)\n",
    "    this_day = datetime.date.today().day\n",
    "    if(this_day!=this_last_up):\n",
    "        \n",
    "        qty_df.at[qty_df.index[qty_df['instrument_token'] == my_inst].tolist()[0],'stop_trading']= False\n",
    "        qty_df.at[qty_df.index[qty_df['instrument_token'] == my_inst].tolist()[0],'last_updated_on']= str(datetime.date.today())\n",
    "        qty_df.at[qty_df.index[qty_df['instrument_token'] == my_inst].tolist()[0],'order_id']= 111111\n",
    "        print('Stop Trading Changed for  : '+str(my_inst))\n",
    "\n",
    "joblib.dump(qty_df,'./qty_df.p')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.929Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "qty_df.to_excel('./qty_df_updated.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.935Z"
    }
   },
   "outputs": [],
   "source": [
    "############################## Get My Qty #########################\n",
    "myquantity = 0\n",
    "def getquant():\n",
    "    global myquantity\n",
    "    allpos = kite.positions()['net']\n",
    "    for i in range(len(allpos)):\n",
    "        for j in qty_df.instrument_token.to_list():\n",
    "            if(allpos[i]['instrument_token']==j and  allpos[i]['product']== 'CO'):\n",
    "                myquantity = allpos[i]['quantity']\n",
    "                qty_df.at[qty_df.index[qty_df['instrument_token'] == j].tolist()[0],'my_qty']= myquantity\n",
    "                this_smb = qty_df.loc[qty_df['instrument_token'] == j]['tradingsymbol'].to_numpy()[0]\n",
    "                print('My Quantity : '+ this_smb + ' : ' + str(allpos[i]['quantity']))\n",
    "    joblib.dump(qty_df,'./qty_df.p')\n",
    "getquant()\n",
    "########################### Place Order ###########################\n",
    "placing_order = False\n",
    "def placeneworder(inst_token,quantdiff,trigger_price):\n",
    "    '''placeneworder(inst_token,quantdiff,trigger_price)'''\n",
    "    global stopbuy,stopsell,placing_order\n",
    "    my_symbol_ip = qty_df.loc[qty_df['instrument_token'] == inst_token]['tradingsymbol'].to_numpy()[0]\n",
    "        \n",
    "    if(quantdiff>0):\n",
    "        placing_order = True\n",
    "        try:\n",
    "            order_id= kite.place_order(tradingsymbol=my_symbol_ip, \n",
    "                        exchange=kite.EXCHANGE_NSE, \n",
    "                        transaction_type=kite.TRANSACTION_TYPE_BUY,\n",
    "                        trigger_price = trigger_price,\n",
    "                        quantity=abs(quantdiff),\n",
    "                        order_type=kite.ORDER_TYPE_MARKET,\n",
    "                        variety = kite.VARIETY_CO,\n",
    "                        product=kite.PRODUCT_CO,)\n",
    "            qty_df.at[qty_df.index[qty_df['instrument_token'] == inst_token].tolist()[0],'stop_trading']= True\n",
    "            qty_df.at[qty_df.index[qty_df['instrument_token'] == inst_token].tolist()[0],'last_updated_on']= datetime.date.today()\n",
    "            qty_df.at[qty_df.index[qty_df['instrument_token'] == inst_token].tolist()[0],'order_id']=order_id\n",
    "            getquant()\n",
    "            joblib.dump(qty_df,'./qty_df.p')\n",
    "        except Exception as e:\n",
    "            print(e)\n",
    "            getquant()\n",
    "        placing_order = False\n",
    "    if(quantdiff<0):\n",
    "        placing_order = True\n",
    "        try:\n",
    "            order_id= kite.place_order(tradingsymbol=my_symbol_ip, \n",
    "                    exchange=kite.EXCHANGE_NSE, \n",
    "                    transaction_type=kite.TRANSACTION_TYPE_SELL,\n",
    "                    trigger_price = trigger_price,\n",
    "                    quantity=abs(quantdiff),\n",
    "                    order_type=kite.ORDER_TYPE_MARKET,\n",
    "                    variety = kite.VARIETY_CO,\n",
    "                    product=kite.PRODUCT_CO,)\n",
    "            qty_df.at[qty_df.index[qty_df['instrument_token'] == inst_token].tolist()[0],'stop_trading']= True\n",
    "            qty_df.at[qty_df.index[qty_df['instrument_token'] == inst_token].tolist()[0],'last_updated_on']= datetime.date.today()\n",
    "            qty_df.at[qty_df.index[qty_df['instrument_token'] == inst_token].tolist()[0],'order_id']=order_id\n",
    "            getquant()\n",
    "            joblib.dump(qty_df,'./qty_df.p')\n",
    "            \n",
    "        except Exception as e:\n",
    "            print(e)\n",
    "            getquant()\n",
    "        placing_order = False\n",
    "############### CHK QTY #####################################\n",
    "def ckqnt (tkn,orderquant,trigger_price):\n",
    "    '''ckqnt (tkn,orderquant,trigger_price)'''\n",
    "    global placing_order\n",
    "    myquantity=qty_df.loc[qty_df['instrument_token'] == tkn]['my_qty'].to_numpy()[0]\n",
    "    quantdiff = orderquant - myquantity\n",
    "    if(placing_order==False and quantdiff!=0):\n",
    "        placeneworder(inst_token=tkn,quantdiff=quantdiff,trigger_price=trigger_price)\n",
    "    return myquantity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.941Z"
    }
   },
   "outputs": [],
   "source": [
    "# from pivottablejs import pivot_ui\n",
    "# from IPython.display import HTML\n",
    "# pvi = pivot_ui(qty_df,outfile_path='./pivottablejs.html')\n",
    "# pvi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.945Z"
    },
    "run_control": {
     "marked": false
    }
   },
   "outputs": [],
   "source": [
    "old_qty_df.to_excel('./old_qty_df.xlsx')\n",
    "qty_df.to_excel('./qty_df.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.949Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "####################### Start Trading #########################\n",
    "import logging\n",
    "import threading\n",
    "from kiteconnect import KiteTicker\n",
    "logging.basicConfig(level=logging.DEBUG)\n",
    "\n",
    "counter = 0\n",
    "\n",
    "def on_ticks(ws, ticks):\n",
    "    global counter\n",
    "    counter = counter + 1\n",
    "    print('==========================')\n",
    "    this_min = datetime.datetime.now().minute\n",
    "    this_hour = datetime.datetime.now().hour\n",
    "\n",
    "    for one_stk_data in ticks:\n",
    "        print('Symbol : ' + str(qty_df.loc[qty_df['instrument_token'] ==\n",
    "                                           one_stk_data['instrument_token']]\n",
    "                                ['tradingsymbol'].to_numpy()[0]))\n",
    "        print('LTP : ' + str(one_stk_data['last_price']))\n",
    "\n",
    "        this_ltp = one_stk_data['last_price']\n",
    "\n",
    "        this_morning_low = qty_df.loc[\n",
    "            qty_df['instrument_token'] ==\n",
    "            one_stk_data['instrument_token']]['morning_low'].to_numpy()[0]\n",
    "        this_morning_high = qty_df.loc[\n",
    "            qty_df['instrument_token'] ==\n",
    "            one_stk_data['instrument_token']]['morning_high'].to_numpy()[0]\n",
    "        this_stk_qty = qty_df.loc[\n",
    "            qty_df['instrument_token'] ==\n",
    "            one_stk_data['instrument_token']]['trade_qty'].to_numpy()[0]\n",
    "        this_stop_trading = qty_df.loc[\n",
    "            qty_df['instrument_token'] ==\n",
    "            one_stk_data['instrument_token']]['stop_trading'].to_numpy()[0]\n",
    "        last_ltp = qty_df.loc[\n",
    "            qty_df['instrument_token'] ==\n",
    "            one_stk_data['instrument_token']]['ltp'].to_numpy()[0]\n",
    "        this_my_qty = qty_df.loc[\n",
    "            qty_df['instrument_token'] ==\n",
    "            one_stk_data['instrument_token']]['my_qty'].to_numpy()[0]\n",
    "        this_order_id = qty_df.loc[\n",
    "            qty_df['instrument_token'] ==\n",
    "            one_stk_data['instrument_token']]['order_id'].to_numpy()[0]\n",
    "        this_buy_exit = qty_df.loc[\n",
    "            qty_df['instrument_token'] ==\n",
    "            one_stk_data['instrument_token']]['buy_exit'].to_numpy()[0]\n",
    "        this_sell_exit = qty_df.loc[\n",
    "            qty_df['instrument_token'] ==\n",
    "            one_stk_data['instrument_token']]['sell_exit'].to_numpy()[0]\n",
    "\n",
    "        this_gap_upper_limit1 = qty_df.loc[\n",
    "            qty_df['instrument_token'] ==\n",
    "            one_stk_data['instrument_token']]['gap_upper_limit'].to_numpy()[0]\n",
    "        this_gap_lower_limit1 = qty_df.loc[\n",
    "            qty_df['instrument_token'] ==\n",
    "            one_stk_data['instrument_token']]['gap_lower_limit'].to_numpy()[0]\n",
    "\n",
    "        qty_df.at[qty_df.index[qty_df['instrument_token'] ==\n",
    "                               one_stk_data['instrument_token']].tolist()[0],\n",
    "                  'ltp'] = this_ltp\n",
    "\n",
    "#         if (nifty_direction == 'sell'):\n",
    "# #             print('Morning Low : ' + str(this_morning_low))\n",
    "#         else:\n",
    "# #             print('Morning High : ' + str(this_morning_high))\n",
    "# #         print('*****************************')\n",
    "\n",
    "        is_9_25_up = this_hour == 9 and this_min <= 25\n",
    "\n",
    "        gap_condition = this_morning_low > this_gap_lower_limit1 and this_morning_high < this_gap_upper_limit1\n",
    "\n",
    "        if (this_hour <= 10 and this_min <= 45 and this_stk_qty != 0\n",
    "                and this_stop_trading == False):\n",
    "            \n",
    "            if (nifty_direction == 'sell' and this_ltp < this_morning_low\n",
    "                    and (is_9_25_up or last_ltp >= this_morning_low)\n",
    "                    and gap_condition):\n",
    "                ckqnt(one_stk_data['instrument_token'], -this_stk_qty,\n",
    "                      this_morning_high)\n",
    "            \n",
    "            if (nifty_direction == 'buy' and this_ltp > this_morning_high\n",
    "                    and (is_9_25_up or last_ltp <= this_morning_high)\n",
    "                    and gap_condition):\n",
    "                ckqnt(one_stk_data['instrument_token'], this_stk_qty,\n",
    "                      this_morning_low)\n",
    "\n",
    "        if (this_my_qty > 0):\n",
    "            x = threading.Thread(target=getquant, args=())\n",
    "            if (nifty_direction == 'sell' and this_ltp <= this_sell_exit):\n",
    "                kite.cancel_order(kite.VARIETY_CO, this_order_id)\n",
    "                x.start()\n",
    "            if (nifty_direction == 'buy' and this_ltp >= this_buy_exit):\n",
    "                kite.cancel_order(kite.VARIETY_CO, this_order_id)\n",
    "                x.start()\n",
    "\n",
    "    if (counter % 10 == 0):\n",
    "        print(counter)\n",
    "        qty_df.to_csv('./live_data.csv')\n",
    "        joblib.dump(qty_df, './qty_df.p')\n",
    "\n",
    "    print('==========================')\n",
    "    print()\n",
    "\n",
    "\n",
    "def on_connect(ws, response):\n",
    "    ws.subscribe(qty_df.instrument_token.to_list())\n",
    "    ws.set_mode(ws.MODE_FULL, qty_df.instrument_token.to_list())\n",
    "\n",
    "def on_close(ws, code, reason):\n",
    "    ws.stop()\n",
    "\n",
    "def on_error(ws, code, reason):\n",
    "    logging.error(\"closed connection on error: {} {}\".format(code, reason))\n",
    "\n",
    "def on_noreconnect(ws):\n",
    "    logging.error(\"Reconnecting the websocket failed\")\n",
    "\n",
    "def on_reconnect(ws, attempt_count):\n",
    "    logging.debug(\"Reconnecting the websocket: {}\".format(attempt_count))\n",
    "\n",
    "def on_order_update(ws, data):\n",
    "    print(\"order update: \", data)\n",
    "\n",
    "kws.on_error = on_error\n",
    "kws.on_noreconnect = on_noreconnect\n",
    "kws.on_reconnect = on_reconnect\n",
    "kws.on_order_update = on_order_update\n",
    "\n",
    "kws.on_ticks = on_ticks\n",
    "kws.on_connect = on_connect\n",
    "kws.on_close = on_close\n",
    "\n",
    "kws.connect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.958Z"
    }
   },
   "outputs": [],
   "source": [
    "# kite.place_order(\n",
    "#     tradingsymbol = 'ONGC',\n",
    "#     transaction_type =kite.TRANSACTION_TYPE_BUY,\n",
    "#     trigger_price = 70.00,\n",
    "#     quantity = 1,\n",
    "#     order_type=kite.ORDER_TYPE_MARKET,\n",
    "#     variety=kite.VARIETY_CO,\n",
    "#     exchange=kite.EXCHANGE_NSE,\n",
    "#     product=kite.PRODUCT_CO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-12-08T04:05:26.962Z"
    }
   },
   "outputs": [],
   "source": [
    "# inst = kite.instruments()\n",
    "# leninst = len(inst)\n",
    "# n50list = []\n",
    "# for i in range(leninst):\n",
    "#     for j in range(len(nifty50)):\n",
    "#         if(inst[i]['tradingsymbol']==nifty50[j] and inst[i]['exchange']=='NSE'):\n",
    "#             n50list.append(inst[i])\n",
    "# n50list\n",
    "# mydf = pd.DataFrame(n50list)  \n",
    "# mydf.to_csv('n50.csv')  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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"
  },
  "output_auto_scroll": true,
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "oldHeight": 495,
   "position": {
    "height": "517px",
    "left": "994px",
    "right": "20px",
    "top": "125px",
    "width": "342px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "varInspector_section_display": "block",
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}