YHT_MNC_NIFTY50_17_11_2020.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-20T05:14:39.695969Z",
     "start_time": "2020-11-20T05:14:16.539053Z"
    },
    "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",
    "# logger.add(\"./logs/MNC_logs_{time}.log\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #######################\n",
    "# # MANUAL LOGIN-1 of 1 #\n",
    "# #######################\n",
    "\n",
    "import logging\n",
    "from kiteconnect import KiteConnect\n",
    "logging.basicConfig(level=logging.ERROR)\n",
    "import threading\n",
    "kite = KiteConnect(api_key=\"w19o0chuo929jxkp\")\n",
    "import joblib\n",
    "kite = joblib.load('kitefile.p')\n",
    "print(kite.login_url())\n",
    "mytoken = input('Enter Token Here : ')  \n",
    "data = kite.generate_session(mytoken,api_secret=\"gsw8ps17ex7lf3cuji4prfnwb4vlyr4y\")\n",
    "kite.set_access_token(data[\"access_token\"])\n",
    "import joblib\n",
    "joblib.dump(kite,'kitefile.p')\n",
    "import act\n",
    "from act import *\n",
    "api_k = \"w19o0chuo929jxkp\"  # api_key\n",
    "api_s = \"gsw8ps17ex7lf3cuji4prfnwb4vlyr4y\"  # api_secret\n",
    "my_ret_token = get_login(api_k, api_s)\n",
    "kws = KiteTicker(\"w19o0chuo929jxkp\", my_ret_token)\n",
    "from loguru import logger\n",
    "logger.add(\"./logs/SUPERTREND_logs_{time}.log\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-20T05:14:39.704035Z",
     "start_time": "2020-11-20T05:14:39.699396Z"
    }
   },
   "outputs": [],
   "source": [
    "############## Parameters #######################\n",
    "my_margin = 400\n",
    "order_type = 'MIS'\n",
    "exchange_type = kite.EXCHANGE_NSE\n",
    "offset_quantity = 0\n",
    "away_from_circuit = 0.50\n",
    "########### Constants ##########\n",
    "n50_token = 256265\n",
    "n50_symbol = 'NIFTY 50'\n",
    "days_ago=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-20T05:14:42.930318Z",
     "start_time": "2020-11-20T05:14:39.706984Z"
    },
    "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_csv('n50.csv')\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-11-20T05:14:42.949652Z",
     "start_time": "2020-11-20T05:14:42.933792Z"
    }
   },
   "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 = x > y ? x : y\n",
    "    margin = margin + (margin * 0.2)\n",
    "    \n",
    "#     y = round(y,4)\n",
    "\n",
    "    return margin\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=1)\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",
    "\n",
    "    mydata = pd.DataFrame(data)\n",
    "    today = datetime.date.today()\n",
    "\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",
    "    tz = pytz.timezone(\"Asia/Calcutta\")\n",
    "    b =tz.localize( datetime.datetime(today.year, today.month, today.day, 9, 15,0,0))\n",
    "    # today.day\n",
    "    timestamp = pd.Timestamp(b)\n",
    "\n",
    "    mycandle = mydata.loc[mydata['date'] == timestamp]\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",
    "           }\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": {
     "end_time": "2020-11-20T05:14:42.961599Z",
     "start_time": "2020-11-20T05:14:42.952785Z"
    }
   },
   "outputs": [],
   "source": [
    "################ 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))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-11-20T05:14:16.529Z"
    },
    "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",
    "    print(i)\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-11-20T05:14:16.532Z"
    }
   },
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-11-20T05:14:16.539Z"
    }
   },
   "outputs": [],
   "source": [
    "################### Decide Qty for Every Symbol #####################\n",
    "total_margin_parts = len(considered_df.instrument_token)\n",
    "per_symbol_margin = my_margin/total_margin_parts\n",
    "\n",
    "qty_df_list = []\n",
    "\n",
    "for inst in considered_df.instrument_token:\n",
    "    this_co_upper = considered_df.loc[considered_df['instrument_token'] == inst]['co_upper'].to_numpy()[0]\n",
    "    this_co_lower = considered_df.loc[considered_df['instrument_token'] == 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'] == inst]['morning_high'].to_numpy()[0]\n",
    "        this_sl = considered_df.loc[considered_df['instrument_token'] == inst]['morning_low'].to_numpy()[0]\n",
    "    else:\n",
    "        this_price = considered_df.loc[considered_df['instrument_token'] == inst]['morning_low'].to_numpy()[0]\n",
    "        this_sl = considered_df.loc[considered_df['instrument_token'] == inst]['morning_high'].to_numpy()[0]\n",
    "    this_marg = calc_margin(this_co_upper,this_co_lower,this_price,stoploss=this_sl,\n",
    "                            transaction_type = nifty_direction) \n",
    "    this_qty = int(per_symbol_margin/this_marg)\n",
    "    qty_df_list.append({'instrument_token':inst,'co_bo_margin':this_marg,\n",
    "                        'trade_qty':this_qty,'my_qty':0,'ltp':0})\n",
    "\n",
    "qty_df = pd.DataFrame(qty_df_list)\n",
    "print('Per Symbol Margin : '+str(per_symbol_margin))\n",
    "\n",
    "qty_df = pd.merge(considered_df,qty_df, on=\"instrument_token\")\n",
    "qty_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-11-20T05:14:16.542Z"
    }
   },
   "outputs": [],
   "source": [
    "############# Get My Qty ########################################\n",
    "myquantity = 0\n",
    "def getquant():\n",
    "    global myquantity\n",
    "    global order_type\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",
    "getquant()\n",
    "################# Place Order #####################################\n",
    "stopbuy = False\n",
    "stopsell = False\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 and stopbuy == False):\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",
    "            getquant()\n",
    "            stopsell = False\n",
    "        except Exception as e:\n",
    "            stopbuy = False\n",
    "            print(e)\n",
    "            getquant()\n",
    "        placing_order = False\n",
    "    if(quantdiff<0 and stopsell == False):\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",
    "            getquant()\n",
    "            stopbuy = False\n",
    "        except Exception as e:\n",
    "            stopsell = True\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-11-20T05:14:16.568Z"
    }
   },
   "outputs": [],
   "source": [
    "############# Start Trading ###############################\n",
    "import logging\n",
    "import threading\n",
    "from kiteconnect import KiteTicker\n",
    "logging.basicConfig(level=logging.DEBUG)\n",
    "\n",
    "def on_ticks(ws, ticks):\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'] == one_stk_data['instrument_token']]\n",
    "                              ['tradingsymbol'].to_numpy()[0]))\n",
    "        print('LTP : '+str(one_stk_data['last_price']))\n",
    "        this_ltp = one_stk_data['last_price']\n",
    "        this_morning_low = qty_df.loc[qty_df['instrument_token'] == one_stk_data['instrument_token']]['morning_low'].to_numpy()[0]\n",
    "        this_morning_high = qty_df.loc[qty_df['instrument_token'] == one_stk_data['instrument_token']]['morning_high'].to_numpy()[0]\n",
    "        this_stk_qty = qty_df.loc[qty_df['instrument_token'] == one_stk_data['instrument_token']]['trade_qty'].to_numpy()[0]\n",
    "        \n",
    "        qty_df.at[qty_df.index[qty_df['instrument_token'] ==  one_stk_data['instrument_token']]\n",
    "                  .tolist()[0],'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",
    "        if(this_hour<=11 and this_min<=1 and this_stk_qty!=0):\n",
    "            if(nifty_direction=='sell' and this_ltp<this_morning_low ):\n",
    "                ckqnt (one_stk_data['instrument_token'],-this_stk_qty,this_morning_high)\n",
    "            if(nifty_direction=='buy' and this_ltp>this_morning_high):\n",
    "                ckqnt (one_stk_data['instrument_token'],this_stk_qty,this_morning_low)\n",
    "\n",
    "    qty_df.to_excel('./live_data.xlsx')\n",
    "    print('==========================')\n",
    "    print()\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": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2020-11-20T05:14:16.582Z"
    }
   },
   "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-11-20T05:14:16.584Z"
    }
   },
   "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')  "
   ]
  }
 ],
 "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"
  },
  "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
}