def login_in_zerodha(api_key, api_secret, user_id, user_pwd, totp_key): driver = uc.Chrome() driver.get(f'https://kite.trade/connect/login?api_key={api_key}&v=3') login_id = WebDriverWait(driver, 10).until(lambda x: x.find_element_by_xpath('//*[@id="userid"]')) login_id.send_keys(user_id) pwd = WebDriverWait(driver, 10).until(lambda x: x.find_element_by_xpath('//*[@id="password"]')) pwd.send_keys(user_pwd) submit = WebDriverWait(driver, 10).until(lambda x: x.find_element_by_xpath('//*[@id="container"]/div/div/div[2]/form/div[4]/button')) submit.click() time.sleep(1) totp = WebDriverWait(driver, 10).until(lambda x: x.find_element_by_xpath('//*[@id="totp"]')) authkey = pyotp.TOTP(totp_key) totp.send_keys(authkey.now()) continue_btn = WebDriverWait(driver, 10).until(lambda x: x.find_element_by_xpath('//*[@id="container"]/div/div/div[2]/form/div[3]/button')) continue_btn.click() time.sleep(5) url = driver.current_url initial_token = url.split('request_token=')[1] request_token = initial_token.split('&')[0] driver.close() kite = KiteConnect(api_key = api_key) #print(request_token) data = kite.generate_session(request_token, api_secret=api_secret) kite.set_access_token(data['access_token']) return kite
def login(self, args): logging.info('==> ZerodhaLogin .args => %s', args) systemConfig = getSystemConfig(Path(__file__).parent.parent.parent) brokerHandle = KiteConnect(api_key=self.brokerAppDetails.appKey) redirectUrl = None if 'request_token' in args: requestToken = args['request_token'] logging.info('Zerodha requestToken = %s', requestToken) session = brokerHandle.generate_session( requestToken, api_secret=self.brokerAppDetails.appSecret) accessToken = session['access_token'] accessToken = accessToken logging.info('Zerodha accessToken = %s', accessToken) brokerHandle.set_access_token(accessToken) logging.info('Zerodha Login successful. accessToken = %s', accessToken) # set broker handle and access token to the instance self.setBrokerHandle(brokerHandle) self.setAccessToken(accessToken) # redirect to home page with query param loggedIn=true homeUrl = systemConfig['homeUrl'] + '?loggedIn=true' logging.info('Zerodha Redirecting to home page %s', homeUrl) redirectUrl = homeUrl else: loginUrl = brokerHandle.login_url() logging.info('Redirecting to zerodha login url = %s', loginUrl) redirectUrl = loginUrl return redirectUrl
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 get_session(): kite = KiteConnect(api_key, api_secret) url = kite.login_url() driver = webdriver.Firefox() driver.get(url) time.sleep(2) login_form = driver.find_element_by_css_selector('div.login-form') formElements = login_form.find_elements_by_class_name('su-input-group') userElement = formElements[0] userIdInput = userElement.find_element_by_css_selector('input') userIdInput.send_keys(user_name) passwordElement = formElements[1] passwordInput = passwordElement.find_element_by_css_selector('input') passwordInput.send_keys(password) login_div = login_form.find_element_by_class_name('actions') submitButton = login_div.find_element_by_css_selector('button') submitButton.click() time.sleep(2) pinElement = driver.find_element_by_class_name('su-input-group') pinInput = pinElement.find_element_by_css_selector('input') pinInput.send_keys(pin) login_div = login_form.find_element_by_class_name('actions') submitButton = login_div.find_element_by_css_selector('button') submitButton.click() time.sleep(2) url = driver.current_url parsed = urlparse.urlparse(url) request_token = parse_qs(parsed.query)['request_token'][0] data = kite.generate_session(request_token, api_secret) access_token = data["access_token"] kite.set_access_token(access_token) driver.close() return kite
def initialize_kite(): """ Helper function to initialize Kite. """ kite = KiteConnect(api_key=KITE_API_KEY) try: with open(path.join(args.path, 'token.ini'), 'r') as the_file: access_token = the_file.readline() try: kite.set_access_token(access_token) except Exception as e: log.error("Authentication failed {}".format(str(e))) raise except FileNotFoundError: try: user = kite.generate_session(KITE_REQUEST_TOKEN, api_secret=KITE_SECRET) except Exception as e: log.error("{}".format(str(e))) exit() with open(path.join(args.path, 'token.ini'), 'w') as the_file: the_file.write(user['access_token']) try: kite.set_access_token(user["access_token"]) except Exception as e: log.error("Authentication failed {}".format(str(e))) raise return kite
def login(getInstruments=False): request_token = kiteLogin() kite = KiteConnect(api_key=api_key) data = kite.generate_session(request_token, api_secret) credentials["access_token"] = data['access_token'] with open("data/credentials.json", "w") as f:json.dump(credentials, f) if getInstruments:updateInstruments()
class TraderLoginView(TemplateView): def get(self, request, **kwargs): status = self.request.GET.get('status', None) force_refresh = self.request.GET.get('force_refresh', None) user_id = "ZZ8276" if status == "success": self.request_token = self.request.GET.get('request_token', None) Options.objects.save_option("request_token", self.request_token) current_time = datetime.datetime.now().time() access_refresh_time = datetime.time(13, 00) if force_refresh: self.remove_access_token() if current_time < access_refresh_time: self.remove_access_token() self.kite = KiteConnect(api_key=KITE_API_KEY) self.get_new_access_token() # collector = Collector(kite_api_key,request_token,user_id,commoditylist) # analyst = Analyst(commoditylist,0)# 0 for commodity, 1 for stocks # kitelalpha = KiteAlpha(kite_api_key,request_token,kite_api_secret) # collector = Collector(kite_api_key,request_token,user_id,stocklist) # analyst = Analyst(stocklist,1,kitelalpha)# 0 for commodity, 1 for stocks return render(request, 'login_success.html', {'token': self.request_token}) else: loginlink = "https://kite.trade/connect/login?v=3&api_key={api_key}".format( api_key=KITE_API_KEY) return render(request, 'login.html', { 'loginlink': loginlink, 'api_key': KITE_API_KEY }) def get_request_token(self): token = Options.objects.get_option("request_token") if not token: return None else: return token def get_new_access_token(self): data = self.kite.generate_session(self.request_token, KITE_API_SECRET) access_token = data["access_token"] Options.objects.save_option("access_token", access_token) Options.objects.save_option( "access_token_last_updated", int(datetime.datetime.now().strftime('%s'))) self.kite.set_access_token(access_token) def remove_access_token(self): Options.objects.clear_option("access_token") Options.objects.clear_option("access_token_last_updated")
class Kite(): def __init__(self, key, secret): self.kite = KiteConnect(api_key=key) try: ## Trying the old access token f = open('at.txt', 'r') access_token = f.read() f.close() #initiating kite self.kite.set_access_token(access_token) except: ##Requesting user to get the new request token print( 'Please open this url in browser and copy the request_token from the redirected url.' ) print(login_url) request_token = str(input("Paste the request token here:")) data = self.kite.generate_session(request_token, api_secret=secret) access_token = data['access_token'] #initiating kite self.kite.set_access_token(access_token) f = open('at.txt', 'w') f.write(access_token) f.close() def get(self): return self.kite
def access(user_name): api_key = "hdtlbz2j74tym170" api_secret = "cdh6zl7tjiokssi1acwt46nft3z6nxx1" request_token_here = user_name kite = KiteConnect(api_key=api_key) data = kite.generate_session(request_token_here, api_secret=api_secret) kite.set_access_token(data["access_token"]) return data["access_token"]
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 login(): logging.basicConfig(level=logging.DEBUG) kite = KiteConnect(api_key="your_api_key") print(kite.login_url()) request_token = input("Enter Request token: ") data = kite.generate_session("request_token_here", api_secret="your_secret") kite.set_access_token(data["access_token"]) return kite
def login(): try: kites = KiteConnect(api_key="nx5fvm3iodrq4ix5") data = kites.generate_session( "kDWQ1n26zi4qhH8XtGz4sftLMR0M4feB", api_secret="s7jpa4hrrpievt66oxqivewy25pc7qf2") kites.set_access_token(data["access_token"]) except Exception as e: print(" ERROR in api_key", e, datetime.datetime.now()) print("user data loaded..........", datetime.datetime.now()) return kites
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 kite_login(): print('Login Time : ' + str(pd.Timestamp('today'))) flag = True print('cwd : '+str(os.getcwd())) browser = webdriver.PhantomJS(executable_path= os.getcwd() + r"\blog\extras\phantomjs-2.1.1-windows\bin\phantomjs") while flag: try: # insert page link browser.get("https://kite.trade/connect/login?api_key=0ld4qxtvnif715ls&v=3") sleep(2) count = 0 # insert credential username = browser.find_element_by_css_selector("input[type='text']") username.send_keys('ZB8746') password = browser.find_element_by_css_selector("input[type='password']") password.send_keys('@KKR357') browser.find_element_by_css_selector("button[type='submit']").click() print('Username: ZB8746') print('Password: @KKR357') sleep(5) question1 = browser.find_elements_by_css_selector("input")[0] question1.send_keys('050991') browser.find_element_by_css_selector("button[type='submit']").click() sleep(5) s = browser.current_url for i in range(10): try: request_token = (s.split('request_token='))[1].split('&action')[0] break except: count += 1 print('try: ', count) sleep(2) pass kite = KiteConnect(api_key="0ld4qxtvnif715ls") api_key="0ld4qxtvnif715ls" api_secret="1lg2kjkba3ol83aospgrovvqd5uvetyn" kite=KiteConnect(api_key,api_secret) dic = kite.generate_session(request_token, api_secret) print('access token = ' +str(dic['access_token'])) UF.set_all_access_token(str(dic['access_token'])) return except: print("ERROR KITE LOGIN") return
def __init__(self): logging.basicConfig(level=logging.DEBUG) # Loading api keys with open("API keys/kite_api.txt", "r") as file: api = file.readlines() kite_api_key = api[0].replace('\n', '') kite_req_token = api[1].replace('\n', '') kite_api_secret = api[2].replace('\n', '') kite = KiteConnect(api_key=kite_api_key) data = kite.generate_session(kite_req_token, api_secret=kite_api_secret)
def getAccessToken(): kite = KiteConnect(api_key=api_key) url = kite.login_url() # print(url) login = requests.get(url) cookies = ';'.join( [f'{k}={v}' for k, v in login.history[1].cookies.items()]) # print(cookies) headers = { 'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:74.0) Gecko/20100101 Firefox/74.0', "X-Kite-Userid": zerodha_id, 'X-Kite-Version': '2.4.0', 'Cookie': cookies, 'Referer': login.url } data = requests.post('https://kite.zerodha.com/api/login', data={ 'user_id': zerodha_id, 'password': zerodha_password }, headers=headers) request_id = data.json()['data']['request_id'] data = requests.post('https://kite.zerodha.com/api/twofa', data={ 'user_id': zerodha_id, 'request_id': request_id, 'twofa_value': zerodha_pin }, headers=headers) public_token = data.json()['data']['public_token'] user_id = 'user_id=' + zerodha_id headers.update({ 'Cookie': cookies + ';' + 'public_token=' + public_token + ';' + user_id }) data = requests.get(login.url + '&skip_session=true', headers=headers) print(data.url) request_token = data.url.split("?")[1].split("&")[0].split("=")[1] data = kite.generate_session(request_token, api_secret) return data["access_token"]
def access_token(self): if not self.__access_token: try: kite_client = KiteConnect(api_key=creds.API_KEY) request_token = self.get_request_token( login_url=(kite_client.login_url())) data = kite_client.generate_session( request_token=request_token, api_secret=creds.API_SECRET) access_token = data.get("access_token", None) if not access_token: print( "No key available in session as access token. sending as None." ) self.__access_token = access_token except Exception as e: print("Error in fetching access token with error %s." % str(e)) return self.__access_token
def loginZerodha(args): userConfig = getUserConfig() global kite kite = KiteConnect(api_key=userConfig['apiKey']) if 'request_token' in args: requestToken = args['request_token'] print('requestToken = ' + requestToken) session = kite.generate_session(requestToken, api_secret=userConfig['apiSecret']) accessToken = session['access_token'] print('accessToken = ' + accessToken) kite.set_access_token(accessToken) holdings = kite.holdings() print('holdings => ', holdings) return '<p>Login successful. accessToken = ' + accessToken + '</p>' else: loginUrl = kite.login_url() print('login url => ' + loginUrl) return redirect(loginUrl, code=302)
class kiteparse: def __init__(self): self.kite = KiteConnect(api_key="2x2f2a8447agu452") print(self.kite.login_url()) access_token = input("Enter token:") data = self.kite.generate_session(access_token, api_secret="kfygfd0sgae19vnmsz49pnd1t44dacb1") self.kite.set_access_token(data["access_token"]) data = self.kite.instruments() self.df = pd.DataFrame(data)[["instrument_token","exchange_token","tradingsymbol","exchange"]] def read_data_backtest(self, symbol_1, interval, exchange="NSE", symbol=True, days=0): instrument = symbol_1 if symbol: dat = self.df.loc[self.df['tradingsymbol'] == symbol_1 , ['exchange','instrument_token']] instrument = dat.loc[dat['exchange'] == exchange, 'instrument_token'].iloc[0] tzinfo = pytz.timezone('Asia/Kolkata') now = datetime.now(tz= tzinfo)#tz= tzinf today = now.date() current_time = time(now.hour, now.minute, now.second) # print(current_time,today, today.weekday()) to_d = datetime.combine(today, current_time)) from_d = datetime.combine(today-timedelta(days=days), time(9, 15, 00))) #from_d = datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0) ohlcv = pd.DataFrame(self.kite.historical_data(instrument_token=instrument,from_date=from_d,to_date=to_d,interval=interval)) return ohlcv, to_d def placeorder(self,item, exchange, action, quantity): try: order_id = self.kite.place_order(tradingsymbol=item, exchange=exchange, transaction_type=action, quantity=quantity, variety="regular", order_type="MARKET", product="MIS") logging.info("Order placed. ID is: {}".format(order_id)) except Exception as e: print(e)
def generate_token(userdata): try: api_key = userdata.loc[0, 'api_key'] api_secret = userdata.loc[0, 'api_secret'] kite = KiteConnect(api_key=api_key) print("Login URL :=> " + kite.login_url()) request_token = input("Enter new request token value : ") res = kite.generate_session(request_token, api_secret) #print(res) userdata.loc[0, 'access_token'] = res['access_token'] userdata.loc[0, 'user_name'] = res['user_name'] userdata.loc[0, 'user_id'] = res['user_id'] userdata.loc[0, 'public_token'] = res['public_token'] userdata.loc[0, 'token_req_date'] = datetime.datetime.now() userdata.to_csv(userdata_file, index=False) except Exception as e: print("** ERROR in Access Token Generation. ", e, datetime.datetime.now())
def generate_session(): """Generates a kite trading session. Returns: (obj): KiteConnect object. """ # Get request_token. request_token = _get_request_token() INFO(f"Request token:{request_token}") INFO("Generating trading session") # Create Kite object and then generate kite trading session. kite = KiteConnect(api_key=CREDENTIALS['api_key']) data = kite.generate_session(request_token, api_secret=CREDENTIALS['api_secret']) # The access_token is vaild till 6am the next day. INFO(f"Access token:{data['access_token']}") kite.set_access_token(data["access_token"]) return kite
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 autologin(): kite = KiteConnect(api_key=api_key) service = webdriver.chrome.service.Service('./chromedriver') service.start() options = webdriver.ChromeOptions() options.add_argument('--headless') options = options.to_capabilities() driver = webdriver.Remote(service.service_url, options) driver.get(kite.login_url()) passwordField = getCssElement(driver, "input[placeholder=Password]") passwordField.send_keys(password) userNameField = getCssElement(driver, "input[placeholder='User ID']") userNameField.send_keys(username) loginButton = getCssElement(driver, "button[type=submit]") loginButton.click() WebDriverWait(driver, 100).until( EC.presence_of_element_located((By.CLASS_NAME, 'twofa-value'))) pinField = driver.find_element_by_class_name( 'twofa-value').find_element_by_xpath(".//input[1]") pinField.send_keys(pin) loginButton = getCssElement(driver, "button[type=submit]") loginButton.click() while True: try: request_token = furl( driver.current_url).args['request_token'].strip() break except: time.sleep(1) kite = KiteConnect(api_key=api_key) data = kite.generate_session(request_token, api_secret=api_secret) with open('access_token.txt', 'w') as file: file.write(data["access_token"]) driver.quit()
class Configurator(object): def __init__(self, driver_path=None): # lazy evaluate the driver inside the get_config and kill it by the end driver = Driver() with driver as d: single_auth = AuthSingletonStack.pop() self.api_key = single_auth["api_key"] self.secret_key = single_auth["secret_key"] self.u_id = single_auth["u_id"] self.password = single_auth["password"] self.kite = KiteConnect(self.api_key, self.secret_key) # Hit the first url and get session_id d.get(self.kite.login_url()) self.session_id = driver.parse_url("sess_id") # login to first auth page user_id = d.find_elements_by_tag_name("input")[0] pwd = d.find_elements_by_tag_name("input")[1] login = d.find_element_by_xpath('//button[@type="submit"]') user_id.send_keys(self.u_id) pwd.send_keys(self.password) login.click() # Wait for second auth page to load and fill the second factor authentication question time.sleep(15) driver.fill_second_factor_auth_question(0) driver.fill_second_factor_auth_question(1) login.click() # return request token from final url self.request_token = driver.parse_url("request_token") self.data = self.kite.generate_session( api_secret=self.secret_key, request_token=self.request_token) self.access_token = self.data["access_token"] self.public_token = self.data["public_token"] self.user_id = self.data["user_id"] self.nfo = self.kite.instruments("NFO")
class OptionChain(): """ Wrapper class to fetch option chain steaming data """ def __init__(self, symbol, expiry, api_key, api_secret=None, request_token=None, access_token=None, underlying=False): self.symbol = symbol self.expiry = expiry self.api_key = api_key self.api_secret = api_secret self.request_token = request_token self.access_token = access_token self.underlying = underlying self.instrumentClass = InstrumentMaster(self.api_key) def sync_instruments(self): """ Sync master instrument to redis """ self.instrumentClass.filter_redis_dump() def create_option_chain(self): """ Wrapper method to fetch sreaming option chain for requested symbol/expiry """ # Assign/generate access_token using request_token and api_secret if self.api_secret and self.request_token: self.kite = KiteConnect(api_key=self.api_key) self.data = self.kite.generate_session(self.request_token, api_secret=self.api_secret) self.access_token = self.data["access_token"] elif self.access_token: self.access_token = self.access_token self.socketClient = WebsocketClient(self.symbol, self.expiry, self.api_key, self.access_token, self.underlying) # create streaming websocket data self.socketClient.queue_callBacks() # Keep fetching streaming Queue while 1: yield self.socketClient.q.get()
def loginZerodha(args): userConfig = getUserConfig() systemConfig = getSystemConfig() global kite kite = KiteConnect(api_key=userConfig['apiKey']) if 'request_token' in args: requestToken = args['request_token'] logging.info('requestToken = %s', requestToken) session = kite.generate_session(requestToken, api_secret=userConfig['apiSecret']) accessToken = session['access_token'] logging.info('accessToken = %s', accessToken) kite.set_access_token(accessToken) logging.info('Login successful. accessToken = %s', accessToken) # redirect to home page with query param loggedIn=true homeUrl = systemConfig['homeUrl'] + '?loggedIn=true' logging.info('Redirecting to home page %s', homeUrl) return redirect(homeUrl, code=302) else: loginUrl = kite.login_url() logging.info('Redirecting to zerodha login url = %s', loginUrl) return redirect(loginUrl, code=302)
def getaccesstoken(self): try: kite = KiteConnect(api_key = self.apiKey) #check if the token already exists #self.lastlogintime = pd.to_datetime(self.lastlogintime) #if self.lastlogintime.date() == datetime.datetime.now().date() and self.lastlogintime.time() > datetime.time(8,0,0): # print('token exists',self.accountUserName) # request_token = self.lastaccesstoken # return request_token #else: #generating new token request_token = self.generate_access_token(kite.login_url()) data = kite.generate_session(request_token, api_secret= self.apiSecret) access_token = data['access_token'] return access_token except Exception as ex: print(ex) raise
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 login_kite(request_token): global config_dict # read config file config_dict = utils.read_config_file() #kite = kite_utils.kite_login(request_token) config = ConfigParser.ConfigParser() config.read(config_dict['data_access']) access_token = config.get('MAIN', 'DATA_ACCESS_TOKEN') my_api = str(config_dict['kite_api_key']) my_api_secret = str(config_dict['kite_api_secret']) kite = KiteConnect(api_key=my_api) url = kite.login_url() print url # Redirect the user to the login url obtained # from kite.login_url(), and receive the request_token # from the registered redirect url after the login flow. # Once you have the request_token, obtain the access_token # as follows. # sys.argv[1] is access token that we get from login if request_token == None: kite.set_access_token(access_token) else: data = kite.generate_session(request_token, api_secret=my_api_secret) kite.set_access_token(data["access_token"]) access_token = data["access_token"] config.set('MAIN', 'DATA_ACCESS_TOKEN', data["access_token"]) with open(config_dict['data_access'], 'wb') as configfile: config.write(configfile) return my_api, access_token, kite