def set_access_token(request):
apii_key = 'l5x8ay13aegnq946'
if request.method == "POST":
accessToken = request.POST["access_token"]
if "order_type" in request.POST:
OT = request.POST["order_type"]
else:
OT = "SL"
if "script_exp" in request.POST:
se = int(request.POST["script_exp"])
else:
se = 1
if "cup" in request.POST:
cp = int(request.POST["cup"])
else:
cp = 1
p = APIINFO(no=1,
api_key=apii_key,
api_token=request.POST["access_token"],
dattime=datetime.now(),
order_type=OT,
script_exposure=se,
cushion_price=cp)
p.save()
return redirect(reverse('trademsg:index'))
else:
try:
p = APIINFO.objects.latest('id')
kite = KiteConnect(api_key=apii_key)
r = requests.get(kite.login_url())
return render(request,
'trademsg/set_access.html',
context={
"url": kite.login_url(),
'data': r.text,
'dd': p
})
except:
kite = KiteConnect(api_key=apii_key)
r = requests.get(kite.login_url())
return render(request,
'trademsg/set_access.html',
context={
"url": kite.login_url(),
'data': r.text
})
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()
waitingEle = 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()
time.sleep(10)
request_token = driver.current_url.split('=')[1].split('&action')[0]
with open('request_token.txt', 'w') as the_file:
the_file.write(request_token)
driver.quit()
time.sleep(10)
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 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 autologin():
token_path = r'C:\Users\deepa\PycharmProjects\zerodha\Fetch_Ticker_Data_Scripts\all_keys.txt'
key_secret = open(token_path, 'r').read().split()
kite = KiteConnect(api_key=key_secret[0])
service = webdriver.chrome.service.Service(
r"C:\Users\deepa\Downloads\chromedriver_win32\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())
driver.implicitly_wait(10)
username = driver.find_element_by_xpath('// *[ @ id = "userid"]')
password = driver.find_element_by_xpath('//*[@id="password"]')
username.send_keys(key_secret[2])
password.send_keys(key_secret[3])
driver.find_element_by_xpath(
'//*[@id="container"]/div/div/div/form/div[4]/button').click()
pin = driver.find_element_by_xpath('//*[@id="pin"]')
pin.send_keys(key_secret[4])
driver.find_element_by_xpath(
'//*[@id="container"]/div/div/div/form/div[3]/button').click()
time.sleep(10)
request_token = driver.current_url.split('=')[1].split('&action')[0]
with open(
r'C:\Users\deepa\PycharmProjects\zerodha\Fetch_Ticker_Data_Scripts\my_request_token.txt',
'w') as the_file:
the_file.write(request_token)
driver.quit()
class KiteData(object):
def __init__(self):
self.kite = KiteConnect(api_key=KITE_API_KEY_VAL)
kite_request_token = get_redirected_url(self.kite.login_url())
data = self.kite.request_access_token(kite_request_token,
secret=KITE_SECRET_KEY_VAL)
self.kite.set_access_token(data[ACCESS_TOKEN])
def get_last_price(self, symbol, exchange):
return self.kite.quote(exchange, symbol)[LAST_PRICE]
def get_account_information(self, param, retries=RETRIES):
for i in xrange(retries):
try:
data = self.account_information_helper()
return data[param]
except:
continue
return None
def account_information_helper(self):
data = self.kite.margins(EQUITY)
return data
# move this somewhere else
def execute_plan(self, plan):
pass
def autologin():
token_path = "api_key.txt"
key_secret = open(token_path, 'r').read().split()
kite = KiteConnect(api_key=key_secret[0])
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())
driver.implicitly_wait(10)
username = driver.find_element_by_xpath(
'/html/body/div[1]/div/div[2]/div[1]/div/div/div[2]/form/div[1]/input')
password = driver.find_element_by_xpath(
'/html/body/div[1]/div/div[2]/div[1]/div/div/div[2]/form/div[2]/input')
username.send_keys(key_secret[2])
password.send_keys(key_secret[3])
driver.find_element_by_xpath(
'/html/body/div[1]/div/div[2]/div[1]/div/div/div[2]/form/div[4]/button'
).click()
pin = driver.find_element_by_xpath(
'/html/body/div[1]/div/div[2]/div[1]/div/div/div[2]/form/div[2]/div/input'
)
pin.send_keys(key_secret[4])
driver.find_element_by_xpath(
'/html/body/div[1]/div/div[2]/div[1]/div/div/div[2]/form/div[3]/button'
).click()
time.sleep(10)
request_token = driver.current_url.split('=')[1].split('&action')[0]
with open('request_token.txt', 'w') as the_file:
the_file.write(request_token)
driver.quit()
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 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 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 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 set_apikey(request):
global kite
global apiKey
if request.method == "POST":
apiKey = request.POST["key"]
request.session['apikey'] = apiKey
kite = KiteConnect(api_key=apiKey)
r = requests.get(kite.login_url())
return render(request,
'trademsg/set_access.html',
context={
"url": kite.login_url(),
'data': r.text
})
else:
return render(request, 'trademsg/set_apikey.html')
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 _get_request_token():
"""
This method logins to the app created and returns the request_token from the
redirect url.
Returns:
(str): request_token.
"""
kite = KiteConnect(api_key=CREDENTIALS['api_key'])
# Start browser object.
INFO("Starting browser")
chromedriver_path = os.environ["AUTOKITE_PATH"] + "/driver/chromedriver"
service = webdriver.chrome.service.Service(chromedriver_path)
service.start()
# Set browser options.
DEBUG("Setting browser options")
options = webdriver.ChromeOptions()
options.add_argument('--headless')
options = options.to_capabilities()
# Open kite app.
DEBUG("Opening the web page in browser")
driver = webdriver.Remote(service.service_url, options)
driver.get(kite.login_url())
driver.implicitly_wait(10)
# Enter credentials and authenticate.
INFO("Authenticating to app")
username = driver.find_element_by_css_selector(CSS['username'])
password = driver.find_element_by_css_selector(CSS['password'])
username.send_keys(CREDENTIALS['user_id'])
password.send_keys(CREDENTIALS['password'])
driver.find_element_by_css_selector(CSS['continue']).click()
pin = driver.find_element_by_css_selector(CSS['pin'])
pin.send_keys(CREDENTIALS['pin'])
driver.find_element_by_css_selector(CSS['login']).click()
time.sleep(10)
# Get request token from redirect_url.
# The request_token is valid for few minutes only, hence generate trading
# session immediately after getting the request_token.
request_token = driver.current_url.split('=')[1].split('&action')[0]
driver.quit()
return request_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 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")
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 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 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
def login_fn():
#logging.basicConfig(level=logging.DEBUG)
with open(config.root_path + 'credentials.csv', mode='r') as infile:
reader = csv.reader(infile)
credential_dict = {rows[0]: rows[1] for rows in reader}
api_key = config.api_key
user_id = config.user_id
password = config.password
twofa_value = config.twofa_value
api_secret = config.api_secret
payload = 'password='******'&user_id=' + user_id
kite = KiteConnect(api_key=api_key)
api_url = kite.login_url()
login_url = config.login_url
two_fa_url = config.two_fa_url
headers = {
'X-Kite-Version': '3',
'Content-Type': 'application/x-www-form-urlencoded'
}
my_session = requests.Session()
response_login = my_session.request("POST",
login_url,
headers=headers,
data=payload)
json_data = json.loads(response_login.text)
request_id = json_data['data']['request_id']
payload2 = 'request_id=' + request_id + '&twofa_value=' + twofa_value + '&user_id=' + user_id
response = my_session.request("POST",
two_fa_url,
headers=headers,
data=payload2)
token_response = my_session.get(api_url)
response_dict = dict(
urllib.parse.parse_qsl(urlparse(token_response.url).query))
request_token = response_dict["request_token"]
success_flag = response_dict["status"]
#data = kite.generate_session(str(request_token), api_secret=secret_api)
#kite.set_access_token(data["access_token"])
auth_url = config.auth_url
session_str = api_key + request_token + api_secret
checksum = hashlib.sha256(str.encode('utf-8')).hexdigest()
payload3 = 'api_key=' + api_key + '&request_token=' + request_token + '&checksum=' + checksum
response3 = requests.request("POST",
auth_url,
headers=headers,
data=payload3)
if (response3.status_code == 200):
#update global access once handled
return "Login Success"
else:
testToken.testToken()
config.access_token = fetchTokenFromFile.fetchTokenFromFile()
return "Login Fail " + str(
response3.status_code) + fetchTokenFromFile.fetchTokenFromFile()
from kiteconnect import KiteConnect
import webbrowser
from flask import Flask, render_template, request
import requests
import hashlib
kite = KiteConnect(api_key="dn9ld7rvexwulult")
webbrowser.open(kite.login_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.
app = Flask(__name__)
req = ""
@app.route('/')
def home():
req = request.args.get("request_token")
api_key = "dn9ld7rvexwulult"
api_secret = "cedkw4emw3c8ybdqoewturi131rv42ur"
# Comes from the redirect parameters.
request_token = req
h = hashlib.sha256(api_key + request_token + api_secret)
checksum = h.hexdigest()
print req
params = {
'api_key': 'dn9ld7rvexwulult',
api_secret = "pehnl80uvmvovido6mjdhcxudxvte6ze"
access_token = "K1pEjHfy2bBCwHKY4GVFrcd3PAXPryrp"
# request_token = "ga94ubDv9OISYgYM37eWcSjm5XFSNi7U"
# publicToken = "c31b29bd22fa6c181388a0c2a133c8c2"
### ---- with apoorv key ---
# kite = KiteConnect(api_key=myApiKey)
# # access_token,public_token,request_token,api_key,api_secret = at.getAll()
# data = kite.generate_session(request_token, api_secret=api_secret)
# kite.set_access_token(data["access_token"])
# kite.set_access_token(access_token)
###----- temp approach -----
kite = KiteConnect(api_key=myApiKey)
print(kite.login_url())
# data = kite.generate_session(request_token, api_secret=api_secret)
# print("Access Token ------------ ",data["access_token"])
kite.set_access_token(access_token)
print("Connection successfull ......")
def postgre_sql_read_df(query):
"""Creates postresql_conn object and closes connection immidiately after usage.
This will help tackle connection pool exceed issue.
Arguments:
query {[String]} -- [SQL query to read data from postgresql and
create a pandas dataframe]
"""
# conn_string_alchemy = "postgresql://*****:*****@finre.cgk4260wbdoi.ap-south-1.rds.amazonaws.com/finre"
config = configparser.ConfigParser()
config.read('kuber.conf')
login_conf = config['Login Configuration']
api_key = login_conf['api_key']
api_secret = login_conf['api_secret']
try:
kite = KiteConnect(api_key, api_secret)
except Exception as e:
print(e)
sys.exit(1)
# print(kite.login_url())
webbrowser.open_new(kite.login_url())
"""
try:
response = urllib.request.urlopen(kite.login_url())
except Exception as e:
print(e)
sys.exit(1)
print(response.geturl())
for instrument in (kite.instruments()):
print(instrument)
print("\n")
"""
class Zerodha(Broker):
"""
Automated Trading class
"""
def __init__(self,
api_key,
secret,
user_id,
password,
PIN,
exchange='NSE',
product='MIS'):
self._api_key = api_key
self._secret = secret
self._user_id = user_id
self._password = password
self._pin = PIN
self.exchange = exchange
self.product = product
self._store_access_token = True
super(Zerodha, self).__init__()
@property
def isNilPositions(self):
"""
return True if there are no open positions
else return False
"""
temp = pd.DataFrame(self.positions()['net'])
if temp.quantity.abs().sum() == 0:
return True
else:
return False
@property
def isNilPositionsDay(self):
"""
return True if there are no open positions for
the day else return False
"""
temp = pd.DataFrame(self.positions()['day'])
if temp.quantity.abs().sum() == 0:
return True
else:
return False
@property
def isNilOrders(self):
"""
return True if there are no pending orders
else return False
"""
pending = [
o for o in self.orders() if o.get('status', 'PENDING') == 'PENDING'
]
if len(pending) == 0:
return True
else:
return False
def cancel_all_orders(self, retries=5):
"""
Cancel all existing orders
"""
for o in self.orders():
try:
if o['status'] == 'PENDING':
self.order_cancel(variety=o['variety'],
order_id=o['order_id'],
parent_order_id=o['parent_order_id'])
except Exception as e:
print(e)
i = 0
while not (self.isNilOrders):
print('Into the loop')
i += 1
for o in self.orders():
try:
if o['status'] == 'PENDING':
self.order_cancel(variety=o['variety'],
order_id=o['order_id'],
parent_order_id=o['parent_order_id'])
except Exception as e:
print(e)
if i > retries:
print('Breaking out of loop without canceling all orders')
break
def _shortcuts(self):
"""
Provides shortcuts to kite functions by mapping functions.
Instead of calling at.kite.quote, you would directly call
at.quote
Note
-----
1) Kite functions are initialized only after authentication
1) Not all functions are supported
"""
self.margins = self.kite.margins
self.profile = self.kite.profile
self.ltp = self.kite.ltp
self.quote = self.kite.quote
self.ohlc = self.kite.ohlc
self.trades = self.kite.trades
self.holdings = self.kite.holdings
self._sides = {'BUY': 'SELL', 'SELL': 'BUY'}
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 _login(self):
import time
self.kite = KiteConnect(api_key=self._api_key)
options = Options()
options.add_argument('--headless')
options.add_argument('--disable-gpu')
driver = webdriver.Chrome(options=options)
driver.get(self.kite.login_url())
login_form = WebDriverWait(driver, 45).until(
EC.presence_of_element_located((By.CLASS_NAME, "login-form")))
login_form.find_elements_by_tag_name('input')[0].send_keys(
self._user_id)
login_form.find_elements_by_tag_name('input')[1].send_keys(
self._password)
WebDriverWait(driver, 45).until(
EC.presence_of_element_located((By.CLASS_NAME, "button-orange")))
driver.find_element_by_xpath('//button[@type="submit"]').click()
twofa_form = WebDriverWait(driver, 45).until(
EC.presence_of_element_located((By.CLASS_NAME, "twofa-form")))
twofa_form.find_elements_by_tag_name('input')[0].send_keys(self._pin)
WebDriverWait(driver, 45).until(
EC.presence_of_element_located((By.CLASS_NAME, "button-orange")))
driver.find_element_by_xpath('//button[@type="submit"]').click()
time.sleep(2)
token = get_key(driver.current_url)
access = self.kite.generate_session(request_token=token,
api_secret=self._secret)
self.kite.set_access_token(access['access_token'])
with open("token.tok", "w") as f:
f.write(access['access_token'])
driver.close()
def get_all_orders_and_positions(self, positions='day'):
"""
Get the summary of all orders and positions
"""
pos = pd.DataFrame(self.positions()[positions])
orders = pd.DataFrame(self.orders())
orders['qty'] = orders.eval('pending_quantity-cancelled_quantity')
orders['typ'] = 'orders'
pos['qty'] = pos['quantity'].abs()
pos['transaction_type'] = [
'SELL' if qty < 0 else 'BUY' for qty in pos.quantity
]
pos['typ'] = 'positions'
cols = ['tradingsymbol', 'transaction_type', 'qty', 'typ']
return pd.concat([pos, orders], sort=False)[cols]
def uncovered(self):
"""
Return the list of uncovered positions
A position is considered unconvered if there is no matching
stop loss or target order.
"""
pass
def get_order_type(self, price, ltp, order):
if order == "BUY":
return 'LIMIT' if price < ltp else 'SL'
elif order == "SELL":
return 'LIMIT' if price > ltp else 'SL'
@post
def orders(self):
status_map = {
'OPEN': 'PENDING',
'COMPLETE': 'COMPLETE',
'CANCELLED': 'CANCELED',
'CANCELLED AMO': 'CANCELED',
'REJECTED': 'REJECTED',
'MODIFY_PENDING': 'PENDING',
'OPEN_PENDING': 'PENDING',
'CANCEL_PENDING': 'PENDING',
'AMO_REQ_RECEIVED': 'PENDING',
'TRIGGER_PENDING': 'PENDING'
}
ords = self.kite.orders()
# Update status
for o in ords:
o['status'] = status_map.get(o['status'], 'PENDING')
return ords
@post
def positions(self):
"""
Return only the positions for the day
"""
pos = self.kite.positions()['day']
for p in pos:
if p['quantity'] > 0:
p['side'] = 'BUY'
else:
p['side'] = 'SELL'
return pos
@pre
def order_place(self, **kwargs):
"""
Place an order
"""
return self.kite.place_order(**kwargs)
def order_cancel(self, order_id, variety='regular', parent_order_id=None):
"""
Cancel an existing order
"""
return self.kite.cancel_order(variety=variety,
order_id=order_id,
parent_order_id=parent_order_id)
def order_modify(self, order_id, variety='regular', **kwargs):
"""
Modify an existing order
Note
----
This is just a basic implementation
So, all changes must be passed as keyword arguments
"""
return self.kite.modify_order(order_id=order_id,
variety=variety,
**kwargs)
def _custom_orders(self, data, **kwargs):
"""
Generate custom orders.
This is for customized usage
data
dataframe with the following columns
open, symbol, price, side, quantity and stop_loss
kwargs
keyword arguments to be included in each order
"""
cols = ['open', 'symbol', 'price', 'quantity', 'side', 'stop_loss']
data = data[cols].to_dict(orient='records')
exchange = kwargs.get('exchange', 'NSE')
sym = ['{e}:{s}'.format(e=exchange, s=x['symbol']) for x in data]
print(sym)
ltps = self.ltp(sym)
ltps = {k[4:]: v['last_price'] for k, v in ltps.items()}
print(ltps)
all_orders = []
replace = {
'symbol': 'tradingsymbol',
'side': 'transaction_type',
}
for d in data:
dct = d.copy()
del dct['stop_loss']
ltp = ltps.get(d['symbol'])
order_type = self.get_order_type(price=dct['price'],
ltp=ltp,
order=dct['side'])
dct['order_type'] = order_type
dct['price'] = round(dct['price'], 2)
# TO DO: Trigger greater if price is low to correct
if order_type == "SL":
dct['trigger_price'] = round(dct['open'] - 0.05, 2)
dct.update(kwargs)
del dct['open'] # Since its no longer needed
all_orders.append(self.rename(dct, keys=replace))
# Second leg for covering orders
for d in data:
try:
dct = d.copy()
del dct['open'] # Since this is not needed here
ltp = ltps.get(dct['symbol'])
dct['side'] = self._sides[dct['side']]
dct['stop_loss'] = round(dct['stop_loss'], 2)
order_type = self.get_order_type(price=dct['stop_loss'],
ltp=ltp,
order=dct['side'])
if order_type == 'SL':
order_type = 'SL-M'
dct['order_type'] = order_type
dct.update(kwargs)
replace.update({'stop_loss': 'trigger_price'})
all_orders.append(self.rename(dct, keys=replace))
except Exception as e:
print(e, self.rename(dct))
return all_orders
def _create_stop(self, **kwargs):
sl = self._create_stop_loss_orders(percent=3, **kwargs)
orders = []
for s in sl:
try:
dct = s.copy()
dct.update({
'exchange': 'NSE',
'product': 'MIS',
'validity': 'DAY',
'variety': 'regular'
})
dct['trigger_price'] = s['price']
symbol = '{e}:{sym}'.format(e='NSE', sym=s['symbol'])
ltp = self.ltp(symbol)[symbol]['last_price']
order_type = self.get_order_type(s['price'], ltp, s['side'])
dct['order_type'] = order_type
orders.append(dct)
except Exception as e:
print(e)
return orders
def cover_all(self, **kwargs):
"""
Place a stop loss for all uncovered orders
"""
orders = self._create_stop(**kwargs)
for o in orders:
try:
print(self.order_place(**o))
except Exception as e:
print(e)
def close_all_positions(self, **kwargs):
"""
Close all existing positions
"""
positions = self.positions()
if kwargs:
positions = self.dict_filter(positions, **kwargs)
if len(positions) > 0:
for position in positions:
qty = abs(position['quantity'])
symbol = position['symbol']
side = self._sides[position['side']]
exchange = position['exchange']
product = position['product']
if qty > 0:
try:
self.order_place(symbol=symbol,
quantity=qty,
order_type='MARKET',
side=side,
variety='regular',
exchange=exchange,
product=product)
except Exception as e:
print(e)
def get_instrument_map(self,
exchange='NSE',
key='tradingsymbol',
value='instrument_token'):
"""
Get the instrument map as a dictionary
exchange
exchange to fetch the symbols and tokens
key
dictionary key to be used as the key
in the output
value
dictionary value to be used as the value
in the output
Note
-----
1) The instrument map is returned as a dictionary with
key as the symbol and instrument token as value
"""
instruments = self.kite.instruments(exchange=exchange)
inst_map = {inst[key]: inst[value] for inst in instruments}
return inst_map
'''
Quantum
A wrapper for kiteconnect
Algorithmic trading module for NSE-India via pykiteconnect & zerodha
'''
#Importing necessary libraries
import webbrowser as wb
import pandas as pd
from kiteconnect import KiteConnect, WebSocket
#api_key,api_secret,user_id given by zerodha
#store it in the working directory in a file called credential
api_key, api_secret, user_id = open('credential',
'r+').read().strip('\n').split(',')
kite = KiteConnect(api_key=api_key)
login_url = kite.login_url()
wb.open(login_url)
#Get the request token after login from webbrowser and put the token here
request_token = ''
auth_data = kite.request_access_token(request_token, secret=api_secret)
access_token = auth_data["access_token"]
public_token = auth_data["public_token"]
kite.set_access_token(access_token)
with open('auth_data.txt', 'r+') as f:
f.write(access_token + ',' + public_token)
#Retrieve instruments token
instrument = kite.instruments()
instrument = pd.DataFrame(instrument)
