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)