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()
