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
