def tick_init(api_key, public_token, id): kws = WebSocket(api_key, public_token, id) make_tick_df() #Remove below line before restarting in order to save data make_tick_file() num = int(input("Enter the number of stocks to subscribe\n")) set_subscription_list(num) # Assign the callbacks. kws.on_tick = on_tick 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(True)
class MarketData(): instrument_list = list() #stock_price = dict() instr_to_stock = dict() def __init__(self, instruments, public_token): # Initialise. global mkt_data self.kws = WebSocket(config.api_key, public_token, config.kite_id) self.publish_file = config.BaseDir_W + "Data\\" + config.LiveDataFile self.instrument_list = list(instruments.values()) # Assign the callbacks. self.kws.on_tick = self.on_tick self.kws.on_connect = self.on_connect self.kws.enable_reconnect(reconnect_interval=5, reconnect_tries=50) # Initialize all prices with 0. instr_to_stock = 12345:BHEL for key in instruments.keys(): #self.stock_price[key] = 0.0 mkt_data[key] = 0.0 self.instr_to_stock[instruments[key]] = key # set time self.time_counter = time.time() def start(self): self.kws.connect(threaded=True) #self.kws.connect() def on_tick(self, tick, ws): global mkt_data for item in tick: #tick_list[item['instrument_token']] = item['last_price'] mkt_data[self.instr_to_stock[ item['instrument_token']]] = item['last_price'] print("Tick ------", time.strftime("%H:%M:%S")) def on_connect(self, ws): ws.subscribe(self.instrument_list)
kite_api_key = "yw8yelu5bpfel8ib" kite_api_secret = "vaddqe1qb3lzorst3uolc1ptdo0l2cku" kws = WebSocket(kite_api_key, 'Kf879HRiMNS0DbOREhO1KyDqRl3J2bWu', "YK8879") def on_ticks(tick, ws): # Callback to receive ticks. #logging.debug("Ticks: {}".format(ticks)) with open("2_4_2018_1", "a+") as f: f.write(str(tick)) print(tick) def on_connect(ws): # Callback on successful connect. # Subscribe to a list of instrument_tokens (RELIANCE and ACC here). ws.subscribe([738561, 5633]) # Set RELIANCE to tick in `full` mode. ws.set_mode(ws.MODE_FULL, [738561, 5633]) # Assign the callbacks. kws.on_tick = 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()
class MarketData( ): instrument_list = list() stock_price = dict() instr_to_stock = dict() def __init__(self,instruments,session_id): # Initialise. self.kws = WebSocket(config.api_key , session_id, config.kite_id) self.publish_file = config.BaseDir_W + "Data\\" + config.LiveDataFile self.instrument_list = list(instruments.values() ) # Assign the callbacks. self.kws.on_tick = self.on_tick self.kws.on_connect = self.on_connect self.kws.enable_reconnect(reconnect_interval=5, reconnect_tries=50) # Initialize all prices with 0. instr_to_stock = 12345:BHEL for key in instruments.keys(): self.stock_price[key] = 0.0 self.instr_to_stock[instruments[key]] = key # set time self.time_counter = time.time() def start(self): #self.kws.connect(threaded=True) self.kws.connect() def on_tick(self,tick, ws): tick_list = dict() # get all data in dict tick_list = 12345:145.0 for item in tick: tick_list[item['instrument_token']] = item['last_price'] #print("Tick ",time.time(), tick_list) print("Tick ---- ",time.strftime("%H:%M:%S") ) # update stock price in dict for key,value in tick_list.items(): stk = self.instr_to_stock[key] # get stock name self.stock_price[stk] = value# create dict = {'BHEL': 125.65, 'WIPRO': 290.25 } print("stock_price dic done---- ",time.strftime("%H:%M:%S") ) # set data in environment variable var_string = "" for stock,price in self.stock_price.items(): var_string += stock + ":" + str(price) + ',' print("var_string formed---- ",time.strftime("%H:%M:%S") ) # write file every x minutes if time.time() - self.time_counter >= config.MarketData_Write_Interval: try: timestart = time.time() with open(self.publish_file, 'w') as f: f.write("TimeStamp:" + time.strftime("%Y%m%d%H%M%S") + ',' + var_string[:-1]) print(time.strftime("%H:%M:%S"), var_string[:-1]) self.time_counter = time.time() print("TIMETAKEN: ",time.time()-timestart) except Exception as e: print("Market data write in file error. ") exit() def on_connect(self,ws): ws.subscribe(self.instrument_list)
# Assign the callbacks. kws.on_tick = on_tick kws.on_connect = on_connect # To enable auto reconnect WebSocket connection in # case of network failure # - First param is interval between reconnection # attempts in seconds. # Callback `on_reconnect` is triggered on every # reconnection attempt. (Default interval is 5 # seconds) # - Second param is maximum number of retries before # the program exits triggering `on_noreconnect` # calback. (Defaults to 50 attempts) # Note that you can also enable auto reconnection # while initialising websocket. # Example `kws = WebSocket("your_api_key", # "your_public_token", "logged_in_user_id", # reconnect=True, reconnect_interval=5, # reconnect_tries=50)` kws.enable_reconnect(reconnect_interval=5, reconnect_tries=50) # Infinite loop on the main thread. Nothing after # this will run. # You have to use the pre-defined callbacks to # manage subscriptions. print(""" Trying to connect... """) kws.connect()
logging.info("WebSocket connection closed") def on_error(): logging.info("WebSocket connection thrown error") # Assign the callbacks. kws.on_tick = on_tick kws.on_connect = on_connect kws.on_close = on_close kws.on_error = on_error # 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) # kws.connect(disable_ssl_verification=True) # for ubuntu count = 0 while True: logging.info( "This is main thread. Will subscribe to each token in tokens list with 5s delay" ) if count < len(tokens): if kws.is_connected(): logging.info("Subscribing to: {}".format(tokens[count])) kws.subscribe([tokens[count]]) kws.set_mode(kws.MODE_LTP, [tokens[count]]) count += 1 else:
kite.set_access_token(rq['access_token']) kite.ohlc("NSE:INFY") #kite.set_access_token('xjsfx1mymtr3j340g2u4hhy1sshrtl6d') kws = WebSocket(kite_api_key, 'Kf879HRiMNS0DbOREhO1KyDqRl3J2bWu', "YK8879") def on_ticks(tick, ws): # Callback to receive ticks. #logging.debug("Ticks: {}".format(ticks)) print(tick) def on_connect(ws): # Callback on successful connect. # Subscribe to a list of instrument_tokens (RELIANCE and ACC here). ws.subscribe([738561, 5633]) # Set RELIANCE to tick in `full` mode. ws.set_mode(ws.MODE_FULL, [738561]) # Assign the callbacks. kws.on_tick = 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(disable_ssl_verification=True, proxy=proxy)