def authenticate(self): """ Authenticates a kite session if access token is already available Looks up token in token.tok file Useful for reconnecting instead of logging in again """ try: self.kite = KiteConnect(api_key=self._api_key) with open('token.tok') as f: access_token = f.read() self.kite.set_access_token(access_token) self.kite.profile() self.ticker = KiteTicker(api_key=self._api_key, access_token=self.kite.access_token) self._shortcuts() except TokenException: print('Into Exception') self._login() self._shortcuts() self.ticker = KiteTicker(api_key=self._api_key, access_token=self.kite.access_token) except: print('Unknown Exception') self._login() self._shortcuts() self.ticker = KiteTicker(api_key=self._api_key, access_token=self.kite.access_token)
def get_ticker(): load_session() if access_token_valid(): return KiteTicker(Property.api_key, session['access_token']) else: logging.info('No access token found!!') while login() == -1: pass return KiteTicker(Property.api_key, session['access_token'])
def start_ticker(tokens, history, auth='', callback=None): kws = KiteTicker("kitefront", "wPXXjA5tJE8KJyWN753rbGnf5lXlzU0Q") kws.socket_url = "wss://ws.zerodha.com/?api_key=kitefront&user_id=MK4445&public_token=wPXXjA5tJE8KJyWN753rbGnf5lXlzU0Q&uid=1587463057403&user-agent=kite3-web&version=2.4.0" def on_ticks(ws, ticks): for tick in ticks: tick['lastPrice'] = tick['last_price'] tick['token'] = tick['instrument_token'] tick['time'] = int(datetime.now().timestamp()) dataFeed.notify(tick) def on_connect(ws, response): print("Subscribing to tokens: ", storage['tokens']) ws.subscribe(storage['tokens']) def on_close(ws, code, reason): pass kws.on_ticks = on_ticks kws.on_connect = on_connect kws.on_close = on_close while (True): if (storage.get('continueMain')): break time.sleep(2) dataManager.load_data(list(storage['tokens'])) print("History loaded") print("WebSocket Connecting") kws.connect()
def get_login(api_k, api_s): global instr,isTickreceived,NFOintr global kws, kite,sripsFortickdata,FOsripsFortickdata kite = KiteConnect(api_key=api_k) print("[*] Generate access Token : ", kite.login_url()) request_tkn = input( "[*]Enter you request tocken here: "); data = kite.generate_session(request_tkn, api_secret=api_s ) kite.set_access_token(data["access_token"]) kws = KiteTicker(api_k, data["access_token"]) instr = kite.instruments("NSE") NFOintr = kite.instruments("NFO") print(len(instr)) '''for scrip in instr: print(scrip['tradingsymbol'])''' df = pd.read_csv("D:\\Dev_Folder\\BankNifty.csv",usecols=['stocks', 'weightage']) df['instrument_token'] = df['stocks'].apply(getInstrumentToken) df['FOinstrument_token'] = df['stocks'].apply(getFOInstrumentToken) df['LotSize'] = df['stocks'].apply(getLotSize) for index, row in df.iterrows(): #print (row["stocks"], row["instrument_token"]) sripsFortickdata.append(row["instrument_token"]) sripsweightage.append(row["weightage"]) FOsripsFortickdata.append(row["FOinstrument_token"]) Lot_Size.append(row["LotSize"]) #sripsFortickdata = df['instrument_token'][:] #print(sripsFortickdata) '''x=0
def intialize_kite_ticker(): with open(KITE_LATEST_ACCESS_CODE_FILE, 'r') as the_file: kite_latest_access_code = the_file.readline() kite = KiteConnect(api_key=KITE_API_KEY) return KiteTicker(KITE_API_KEY, kite_latest_access_code)
def kite_ticker_handler(manager, msg): global kws, kite, kite_api_key, access_token pdebug('kite_ticker_handler: {}'.format(msg)) # 1: Start kite websocket connections # Initialise if kws is None and msg != 'INIT': return pdebug('kite_ticker_handler: Exec {}'.format(msg)) if msg == 'INIT': try: cache.set('KiteAPIKey',kite_api_key) access_token = cache.get('access_token') kite.set_access_token(access_token) pinfo(kite.access_token) kws = KiteTicker(kite_api_key, kite.access_token) # Assign the callbacks. kws.on_ticks = on_ticks kws.on_connect = on_connect kws.on_order_update = on_order_update #kws.on_close = on_close cache.publish('kite_ticker_handler'+cache_postfix,'START') except Exception as e: perror('Could not connect to KITE server: {}'.format(e)) elif msg == 'START': kws.connect(threaded=True) #kws.subscribe(value) #kws.set_mode(kws.MODE_LTP, value) #Default mode LTP elif msg == 'STATUS': pinfo(kws.is_connected()) elif msg == 'CLOSE': cache.set('Kite_Status','closed') cache.publish('ohlc_tick_handler'+cache_id,'stop') #cache.publish('ohlc_tick_handler'+cache_id,'stop') kws.close() elif msg == 'profile': pinfo(kite.profile()) else: try: msg_j = json.loads(msg) cmd = msg_j['cmd'] value = msg_j['value'] mode_map = {'ltp':kws.MODE_LTP, 'full':kws.MODE_FULL, 'quote': kws.MODE_QUOTE} mode = mode_map[msg_j['mode']] if cmd == 'add': kws.subscribe(value) kws.set_mode(mode, value) pinfo('Subscribe: {}: {}'.format(cmd, msg)) elif cmd == 'remove': kws.unsubscribe(value) pinfo('Un-Subscribe: {}: {}'.format(cmd, msg)) elif cmd == 'mode': pinfo('Set Mode: {}: {}'.format(cmd, msg)) kws.set_mode(mode, value) except: pass
def on_close(ws, code, reason): print('close') loginfile = open("LoginDetail.txt", 'r') loginlst = eval(loginfile.read()) access_token = loginlst['access_token'] # Initialise global kws kws = KiteTicker("0ld4qxtvnif715ls", access_token) main_function()
def kiteticker(): """Init Kite ticker object.""" kws = KiteTicker("<API-KEY>", "<PUB-TOKEN>", "<USER-ID>", debug=True, reconnect=False) kws.socket_url = "ws://127.0.0.1:9000?api_key=<API-KEY>?&user_id=<USER-ID>&public_token=<PUBLIC-TOKEN>" return kws
def StartTicker(): tokenManager = TokenManager.GetInstance() kws = KiteTicker(tokenManager.GetApiKey(), tokenManager.GetAccessToken()) # Assign the callbacks. kws.on_ticks = on_ticks kws.on_connect = on_connect kws.on_close = on_close kws.on_message = on_message kws.connect()
def __init__(self, symbol, expiry, api_key, acess_token, underlying): # Create kite ticker instance self.kws = KiteTicker(api_key, acess_token, debug=True) self.symbol = symbol self.expiry = expiry self.underlying = underlying self.instrumentClass = InstrumentMaster(api_key) self.token_list = self.instrumentClass.fetch_contract( self.symbol, str(self.expiry), self.underlying) self.q = Queue()
def __init__(self, api_key, api_secret, request_token, symbol, expiry): # Create kite connect instance self.kite = KiteConnect(api_key=api_key) self.data = self.kite.generate_session(request_token, api_secret=api_secret) self.kws = KiteTicker(api_key, self.data["access_token"], debug=True) self.symbol = symbol self.expiry = expiry self.instrumentClass = InstrumentMaster(api_key) self.token_list = self.instrumentClass.fetch_contract(self.symbol, str(self.expiry)) self.q = Queue()
def get_login(api_k, api_s): # log in to zerodha API panel global kws, kite kite = KiteConnect(api_key=api_k) print("[*] Generate access Token : ", kite.login_url()) request_tkn = input("[*] Enter Your Request Token Here : ") data = kite.generate_session(request_tkn, api_secret=api_s) kite.set_access_token(data["access_token"]) kws = KiteTicker(api_k, data["access_token"]) print(data['access_token'])
def auto_login(): global kite, kws, data, _ztoken, actual_token _ztoken = ZerodhaAccessToken() actual_token = _ztoken.getaccesstoken() print('access token : ' + str(actual_token)) kite = KiteConnect(api_key=_ztoken.apiKey) data = kite.generate_session(actual_token, api_secret=_ztoken.apiSecret) kite.set_access_token(data["access_token"]) print('request token : ' + str(data["access_token"])) joblib.dump(kite, 'kitefile.p') kws = KiteTicker(_ztoken.apiKey, data["access_token"])
def __init__(self, symbol, expiry, api_key, acess_token): # Create kite ticker instance self.kws = KiteTicker(api_key, acess_token, debug=True) self.symbol = symbol self.expiry = expiry self.instrumentClass = InstrumentMaster(api_key) self.token_list = self.instrumentClass.fetch_contract( self.symbol, str(self.expiry)) self.q = Queue() # Set access_token for Quote API call self.kite.set_access_token(self.data["access_token"])
def login(api_key,api_s): global kws,kite kite = KiteConnect(api_key=api_key) #print("Get Your request token",kite.login_url()) #request_tkn = input("[*] Enter your request token here :") #data = kite.generate_session(request_tkn, api_secret=api_s) #kws = KiteTicker(api_key,data["access_token"]) #kite.set_access_token(data["access_token"]) #print(data["access_token"]) kite.set_access_token(access_token) kws = KiteTicker(api_key,access_token)
def get_login(api_k="w19o0chuo929jxkp", api_s="gsw8ps17ex7lf3cuji4prfnwb4vlyr4y" ): # log in to zerodha API panel global kws, kite kite = KiteConnect(api_key=api_k) print("[*] Generate access Token : ", kite.login_url()) request_tkn = input("[*] Enter Your Request Token Here : ") data = kite.generate_session(request_tkn, api_secret=api_s) kite.set_access_token(data["access_token"]) kws = KiteTicker(api_k, data["access_token"]) print(data['access_token'])
def __init__(self, kite, zerodha_access_token, tracker_token, instruments, df1, df2): # kite ticker initialization self.kws = KiteTicker(df2.iloc[0, 0], zerodha_access_token) self.kite = kite # self.kite.set_access_token(self.access_token) self.zerodha_access_token = zerodha_access_token self.tracker_token = tracker_token self.df1 = df1 self.df2 = df2 self.instruments = instruments self.ticks_queue = Queue() self.exit = 0
def ticker(self, api_key='kitefront', enctoken=None, userid=None): if enctoken is not None: self.enctoken = enctoken if userid is not None: self.user_id = userid if self.user_id is None: raise Exception( f'userid cannot be none, either login with credentials first or set userid here' ) return KiteTicker(api_key=api_key, access_token=self.enctoken + '&user_id=' + self.user_id, root='wss://ws.zerodha.com')
def ticker(self, api_key='kitefront', enctoken=None, userid=None): if enctoken is not None: self.enctoken = self.r.cookies['enc_token'] if userid is not None: self.user_id = self.user_id if self.user_id is None: raise Exception( "\nCould not find the session, Please start a session using \n\n$ jtrader zerodha startsession" ) return KiteTicker(api_key=api_key, access_token=self.enc_token + '&user_id=' + self.user_id, root='wss://ws.zerodha.com')
def get_login(api_k, api_s): # log in to zerodha API panel global kws, kite kite = KiteConnect(api_key=api_k) # print("[*] Generate access Token : ", kite.login_url()) # request_tkn = input("[*] Enter Your Request Token Here : ") # data = kite.generate_session(request_tkn, api_secret=api_s) # kite.set_access_token(data["access_token"]) # kws = KiteTicker(api_k, data["access_token"]) # print(data['access_token']) # # # pdb.set_trace() kite.set_access_token('4maiAltaCdRHSD8Q4RjbrjpHgYNQYUZl') kws = KiteTicker(api_k, '4maiAltaCdRHSD8Q4RjbrjpHgYNQYUZl')
def get_login(api_k, api_s): global kws, kite kite = KiteConnect(api_key=api_k) print("Logging into zerodha") if filename not in os.listdir(): print("you haven't logged it for today") print("[*] Generate Request Token : ", kite.login_url()) request_tkn = input("[*] Enter Your Request Token Here : ") data = kite.generate_session(request_tkn, api_secret=api_s) access_token = data["access_token"] kite.set_access_token(access_token) kws = KiteTicker(api_k, access_token) send_access_token_to_file(access_token) elif filename in os.listdir(): access_token = read_access_token_from_file() kite.set_access_token(access_token) kws = KiteTicker(api_k, access_token) print("You have already loggged in for today") return kite
def kite_ticker_client(self): if not self.__kt_client: try: if not self.access_token: print("Error in retrieving access token") raise Exception( "Cannot create kite ticket object as no access token is available." ) kite_ticker = KiteTicker(creds.API_KEY, access_token=self.access_token) self.__kt_client = kite_ticker except Exception as e: print("Error in getting kite Ticker Object : %s" % str(e)) print(traceback.format_exc()) return self.__kt_client
def sim_init(self): if not self.kite_state.simulationInitSuccessful: # Initialise ticker = KiteTicker(self.api_key, self.access_token) instrument_tokens = self.kite_state.companyTokens.copy() profit_slab = self.kite_state.profitSlab buy_dict = dict() # Defining the callbacks def on_ticks(tick, ticks_info): # global buy_dict for tick_info in ticks_info: # TODO : Check if the order is correct buy_dict[tick_info['instrument_token']] = tick_info['depth']['sell'][0]['price'] tick.close() def on_connect(tick, response): # global instrument_tokens tick.subscribe(self.kite_state.companyTokens) tick.set_mode(tick.MODE_FULL, self.kite_state.companyTokens) def on_close(tick, code, reason): tick.stop() Logger.info('Connection closed successfully!') # Assign the callbacks. ticker.on_ticks = on_ticks ticker.on_connect = on_connect ticker.on_close = on_close ticker.connect() # Building buy list buy_list = list() for token in instrument_tokens: buy_list.append(buy_dict[token]) final_buy_list = list() for buy, low in zip(buy_list, self.kite_state.lowPrice): if buy < 1: final_buy_list.append(low) else: final_buy_list.append(buy) self.kite_state.buyPrice = final_buy_list # TODO: Round off all calculations like this upto 2 decimal places, perfectly divisible by 0.05 self.kite_state.profitablePrice = (np.array(final_buy_list) + np.array(self.kite_state.profitSlab)).tolist() self.kite_state.simulationInitSuccessful = True self.kite_state.save()
def get_login(api_k, api_s): # log in to zerodha API panel try: print("trying to login...") global kite, login_flag, kws kite = KiteConnect(api_key=api_k) access_token = fetch_access_token() kite.set_access_token(access_token) kws = KiteTicker(api_k, access_token) login_flag = 1 bot.sendMessage(chat_id=984101934, text="you are now logged in for today") print("you are now logged in for today") except Exception as e: bot.sendMessage(chat_id=984101934, text="update api key, not able to login") print(e)
def __init__(self): KiteCore.kite = KiteConnect(api_key=KiteCore.api_key) if not KiteCore.request_token: self.__getRequestToken() print("Request token =" + KiteCore.request_token) if not KiteCore.access_token: try: self.__getAccessToken() print("Access Token =" + KiteCore.access_token) except: print("access token generation failed") exit() KiteCore.webSocket = KiteTicker(KiteCore.api_key, KiteCore.access_token)
def start_collecting(self): # Assign the callbacks. ticksdir = os.path.join(os.getcwd(), 'ticks') if not os.path.exists(ticksdir): os.makedirs(ticksdir) kwsone = KiteTicker(self.api_key, self.access_token) kwsone.on_ticks = self.on_tick() kwsone.on_connect = self.on_connect(self.stocklist) if self.postback: kwsone.on_order_update = self.on_order_update() kwsone.connect(threaded=True)
def ticker_service(): kite = KiteConnect(api_key=api_key) kite.set_access_token(access_token) kws = KiteTicker(api_key, access_token) tokens = [138098692] def on_ticks(ws, ticks): pprint(ticks) # Callback for successful connection. def on_connect(ws, response): logging.info("Successfully connected. Response: {}".format(response)) ws.subscribe(tokens) ws.set_mode(ws.MODE_FULL, tokens) logging.info("Subscribe to tokens in Full mode: {}".format(tokens)) # Callback when current connection is closed. def on_close(ws, code, reason): logging.info("Connection closed: {code} - {reason}".format(code=code, reason=reason)) # Callback when connection closed with error. def on_error(ws, code, reason): logging.info("Connection error: {code} - {reason}".format(code=code, reason=reason)) # Callback when reconnect is on progress def on_reconnect(ws, attempts_count): logging.info("Reconnecting: {}".format(attempts_count)) # Callback when all reconnect failed (exhausted max retries) def on_noreconnect(ws): logging.info("Reconnect failed.") # Assign the callbacks. kws.on_ticks = on_ticks kws.on_close = on_close kws.on_error = on_error kws.on_connect = on_connect kws.on_reconnect = on_reconnect kws.on_noreconnect = on_noreconnect # Infinite loop on the main thread. Nothing after this will run. # You have to use the pre-defined callbacks to manage subscriptions. kws.connect(threaded=True) return kws
def tickkkkk(api_key, access_token): kite = KiteConnect(api_key=api_key) kite.set_access_token(access_token) kws = KiteTicker(api_key, access_token) inst_token = [5633] def on_ticks(ws, ticks): for ticks in ticks: price = ticks['last_price'] return price def on_connect(ws, response): ws.subscribe(inst_token) ws.set_mode(ws.MODE_QUOTE, inst_token) kws.on_ticks = on_ticks kws.on_connect = on_connect kws.connect()
def startTicker(self): brokerAppDetails = self.brokerLogin.getBrokerAppDetails() accessToken = self.brokerLogin.getAccessToken() if accessToken == None: logging.error('ZerodhaTicker startTicker: Cannot start ticker as accessToken is empty') return ticker = KiteTicker(brokerAppDetails.appKey, accessToken) ticker.on_connect = self.on_connect ticker.on_close = self.on_close ticker.on_error = self.on_error ticker.on_reconnect = self.on_reconnect ticker.on_noreconnect = self.on_noreconnect ticker.on_ticks = self.on_ticks ticker.on_order_update = self.on_order_update logging.info('ZerodhaTicker: Going to connect..') self.ticker = ticker self.ticker.connect(threaded=True)
def startTicker(): userConfig = getUserConfig() accessToken = getAccessToken() if accessToken == None: logging.error( 'startTicker: Cannot start ticker as accessToken is empty') return global ticker ticker = KiteTicker(userConfig['apiKey'], accessToken) ticker.on_connect = onConnect ticker.on_close = onDisconnect ticker.on_error = onError ticker.on_reconnect = onReconnect ticker.on_noreconnect = onMaxReconnectsAttempt ticker.on_ticks = onNewTicks ticker.on_order_update = onOrderUpdate logging.info('Ticker: Going to connect..') ticker.connect(threaded=True)