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 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 __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 __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, 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 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 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 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 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 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 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 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 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 __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 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 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 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 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 __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 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 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 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 initialize_token(): global kite, kws driver = webdriver.Chrome('chromedriver.exe') api_key = '' api_secret = '' kite = KiteConnect(api_key) print(kite.login_url()) driver.get(kite.login_url()) driver.implicitly_wait(50) username = driver.find_element_by_xpath( '//*[@id="container"]/div/div/div[2]/form/div[1]/input') password = driver.find_element_by_xpath( '//*[@id="container"]/div/div/div[2]/form/div[2]/input') username.send_keys("") password.send_keys("") driver.find_element_by_xpath( '//*[@id="container"]/div/div/div[2]/form/div[4]/button').click() driver.implicitly_wait(50) pin = driver.find_element_by_xpath( '//*[@id="container"]/div/div/div[2]/form/div[2]/div/input') pin.send_keys("") driver.implicitly_wait(50) driver.find_element_by_xpath( '//*[@id="container"]/div/div/div[2]/form/div[3]/button').click() time.sleep(5) code = driver.current_url code = re.split("[?=|&]", code) for i in range(0, len(code)): if code[i] == 'request_token': j = i + 1 code1 = code[j] data = kite.generate_session(code1, api_secret) kite.set_access_token(data["access_token"]) kws = KiteTicker(api_key, data["access_token"]) driver.close()
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 tick_source(api_key, access_token, subscription, additional_data_df): kws = KiteTicker(api_key=api_key, access_token=access_token) def on_ticks(ws, ticks): start = time.time() timestamp = datetime.datetime.fromtimestamp(start).strftime( '%Y-%m-%d %H:%M:%S') pd_ticks = pd.DataFrame(ticks) pd_ticks = pd_ticks.set_index('instrument_token') pd_ticks = pd.concat([pd_ticks, additional_data_df], axis=1, join_axes=[pd_ticks.index]).reset_index() pd_ticks['date'] = timestamp dict_ticks = pd_ticks.to_dict(orient='records') for tick in dict_ticks: if tick['last_price'] != 0: print(tick) producer.send('trigger', json.dumps(tick).encode('utf-8')) end = time.time() print('time taken update->', start - end) def on_connect(ws, response): # Callback on successful connect. # Subscribe to a list of instrument_tokens (VMART and TATAMOTORS here). ws.subscribe(subscription) print('connect') # Set VMART to tick in `full` mode. ws.set_mode(ws.MODE_LTP, subscription) # Assign the callbacks. kws.on_ticks = on_ticks kws.on_connect = on_connect # Infinite loop on the main thread. Nothing after this will run. # You have to use the pre-defined callbacks to manage subscriptions. kws.connect()