def token(request):
kite = KiteConnect(api_key=apiKey)
if 'access_token' in request.session:
accessToken = request.session['access_token']
kite = KiteConnect(api_key=request.session['apikey'])
kite.set_access_token(accessToken)
return redirect(reverse('trademsg:index'))
if request.method == "POST":
request.session['access_token'] = request.POST["access_token"]
request.session.set_expiry(how_many_seconds_until_midnight())
accessToken = request.POST["access_token"]
kite = KiteConnect(api_key=request.session['apikey'])
p = APIINFO(no=1,
api_key=request.session['apikey'],
api_token=request.POST["access_token"],
dattime=datetime.now())
p.save()
kite.set_access_token(accessToken)
return redirect(reverse('trademsg:index'))
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(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()
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 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()
def login():
request_token = request.args.get("request_token")
if not request_token:
return """
<span style="color: red">Error while generating request token.</span><a href='/'>
Try again.<a>"""
kite = KiteConnect(api_key=kite_api_key)
data = kite.request_access_token(request_token, secret=kite_api_secret)
holdings_url = ("https://api.kite.trade/portfolio/holdings"
"?api_key={api_key}&access_token={access_token}").format(
api_key=kite_api_key,
access_token=data["access_token"])
orders_url = ("https://api.kite.trade/orders"
"?api_key={api_key}&access_token={access_token}").format(
api_key=kite_api_key, access_token=data["access_token"])
return login_template.format(access_token=data["access_token"],
user_data=json.dumps(data,
indent=4,
sort_keys=True),
holdings_url=holdings_url,
orders_url=orders_url)
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
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")
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 handle(self, *args, **options):
try:
kite_api_key = "8sawti1bam50o624"
user_id = "ZZ8276"
kite_api_secret = "oum6c2bnqtnhz1os5qmz6saaz7yxxts1"
stocklist = json.loads(Options.objects.get_option("futuresstocklist"))
commoditylist = [53556743,53480199,53470983,53709575,53645831,53645319]
kite = KiteConnect(api_key=kite_api_key)
access_token = get_access_token(kite)
kite.set_access_token(access_token)
Collector(user_id,kite_api_key,access_token,commoditylist)
while True:
pass
except Exception as e:
print(e)
traceback.print_exc()
data={}
data['message'] = str(e)
event = "Error"
# send_push("Backtest","Failed")
def main():
print("Hello Option Chain!")
api_key = open('api_key.txt', 'r').read()
api_secret = open('api_secret.txt', 'r').read()
api_access_token = open("api_access_token.txt", 'r').read()
print("api_key : ", api_key)
print("api_secret : ", api_secret)
print("api_access_token : ", api_access_token)
kite = KiteConnect(api_key=api_key)
kite.set_access_token(api_access_token)
odr = OptionsDataRetriever()
odr.initiateOptionsData(kite)
print("BNF Spot", odr.getBankNiftySpot())
print("BNF ATM", odr.getBankNiftyATM())
CE_Chain = odr.getOpionsChainCE()
print(CE_Chain[['strike', 'expiry', 'IV', 'Delta']])
PE_Chain = odr.getOpionsChainPE(Strike="37900", Length="6")
print(PE_Chain[['strike', 'expiry', 'IV', 'Delta']])
def get_kite_client():
"""Returns a kite client object
"""
kite = KiteConnect(api_key=kite_api_key)
if "access_token" in session:
kite.set_access_token(session["access_token"])
return kite
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)
class FlaskKiteConnect(object):
"""
Flask extension for kiteconnect api
app = Flask(__name__)
kiteconnect = FlaskKiteConnect(app)
"""
def __init__(self, app=None):
self._client = None
if app is not None:
self.init_app(app)
def init_app(self, app):
"""Initialize the kiteconnect client
:param app: Flask app instance
"""
self._client = KiteConnect(app.config.get('KITECONNECT_API_KEY'))
access_token = app.config.get('KITECONNECT_ACCESS_TOKEN')
if access_token:
self._client.set_access_token(access_token)
def __getattr__(self, name):
"""Proxy methods to the private held object
"""
return getattr(self._client, name)
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 InitialiseKite(self):
logging.info("Kite order manager statring...")
tokenManager = TokenManager.GetInstance()
apiKey = tokenManager.GetApiKey()
accessToken = tokenManager.GetAccessToken()
self.kite = KiteConnect(api_key=apiKey)
self.kite.set_access_token(accessToken)
logging.info("Kite order manager complete...")
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 __init__(self, api_key):
self.fno_file = 'https://archives.nseindia.com/content/fo/fo_mktlots.csv'
self.kite = KiteConnect(api_key=api_key)
self.headers = {
'User-Agent':
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36'
}
self.redis_db = InstrumentDumpFetch()
def index(request):
ctx = {}
ctx['access_token'] = request.session.get('access_token', '')
if ctx['access_token']:
kite = KiteConnect(api_key=api_key)
kite.set_access_token(ctx['access_token'])
ctx['orders'] = kite.instruments()[:10]
return render(request, "main/index.html", ctx)
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_access(self):
access_token = open("access_token.txt", "r").read()
key_secret = open("api_key.txt", "r").read().split()
kite = KiteConnect(api_key=key_secret[0])
kite.set_access_token(access_token)
instrument_df = pd.read_csv(instrument_df_loc)
self.kite = kite
self.instrument_df = instrument_df
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 init_app(self, app):
"""Initialize the kiteconnect client
:param app: Flask app instance
"""
self._client = KiteConnect(app.config.get('KITECONNECT_API_KEY'))
access_token = app.config.get('KITECONNECT_ACCESS_TOKEN')
if access_token:
self._client.set_access_token(access_token)
def main():
#print("ddf")
#zerodha_access_token = []
wb = load_workbook('zerotha_scanner.xlsx')
ws1 = wb["zerotha_scanner"]
data = ws1.values
# Get the first line in file as a header line
columns = next(data)[0:]
# Create a DataFrame based on the second and subsequent lines of data
df1 = pd.DataFrame(data, columns=columns)
'''
ws2 = wb["Sheet2"]
data = ws2.values
# Get the first line in file as a header line
columns = next(data)[0:]
# Create a DataFrame based on the second and subsequent lines of data
df2 = pd.DataFrame(data, columns=columns)'''
#df1=pd.read_excel("zerotha_scanner.xlsx")
df2 = pd.read_csv("zerotha_scanner_credentials.csv")
print(df1)
print(df2)
zerodha = ZerodhaAccessToken(df2.iloc[0, 0], df2.iloc[0, 1],
df2.iloc[0, 4], df2.iloc[0, 2], df2.iloc[0,
3])
access_token = zerodha.getaccesstoken()
kite = KiteConnect(api_key=df2.iloc[0, 0])
kite.set_access_token(access_token)
print(access_token)
#zerodha_access_token.append(access_token)
#kite=ClientZerodha(api_key = 6zfi2amoxjco04yo, zerodha_id = RP7365, kite = kite,multiplier = multiplier, api_secret = p2zkzvivv3y8fveacsb9ciqnu5y71iul, pin = 244280,access_token = access_token, password = chicu24428)
instruments = kite.instruments()
#print(instruments)
symbol = []
tracker_token = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
for i in range(df1.shape[0]):
symbol.append(df1.iloc[i, 0])
print(symbol)
for instrument in instruments:
for i in range(df1.shape[0]):
if instrument['tradingsymbol'] == symbol[i]:
tracker_token[i] = instrument['instrument_token']
elif tracker_token[i] == 0:
tracker_token[i] = 1
print(tracker_token)
tracker_token[:] = (value for value in tracker_token if value != 0)
print(tracker_token)
count = 0
for i in tracker_token:
if i == 1:
print(df1.iloc[count, 0], "tracker token doesnt exist")
count += 1
tracker_token[:] = (value for value in tracker_token if value != 1)
return kite, access_token, tracker_token, instruments, df1, df2
def get_kite_client():
"""Returns a kite client object
"""
kite = KiteConnect(Property.api_key)
if "access_token" in session.keys():
kite.set_access_token(session["access_token"])
else:
logging.warn("Access token not found in Session variable")
return -1
return kite
def __init__(self, data, api_key, access_token):
self.activated = False
self.data = data
self.kite = KiteConnect(api_key=api_key)
self.kite.set_access_token(access_token=access_token)
self.long_position = False
self.short_position = False
self.master_df_updated = pd.DataFrame
self.buy_price = None
self.sell_price = None
def __init__(self, api_key, api_secret, request_token, symbol, expiry):
# Create kite connect instance
self.kite = KiteConnect(api_key=api_key)
self.data = self.kite.generate_session(request_token, api_secret=api_secret)
self.kws = KiteTicker(api_key, self.data["access_token"], debug=True)
self.symbol = symbol
self.expiry = expiry
self.instrumentClass = InstrumentMaster(api_key)
self.token_list = self.instrumentClass.fetch_contract(self.symbol, str(self.expiry))
self.q = Queue()
def __init__(self):
# Get the request token
try:
request_token = Get_Request_Token()
self.kite = KiteConnect(config.api_key,config.secret_key)
data = self.kite.request_access_token(request_token, config.secret_key )
self.kite.set_access_token(data["access_token"])
except :
lg.error("Error in kite connection")
exit()
def get_access(self):
cwd = os.path.join(os.getcwd(), "sensitive")
instrument_df_loc = os.path.join(cwd, "nse_tickers.csv")
access_token = open(os.path.join(cwd, "access_token.txt"), "r").read()
key_secret = open(os.path.join(cwd, "api_key.txt"), "r").read().split()
kite = KiteConnect(api_key=key_secret[0])
kite.set_access_token(access_token)
instrument_df = pd.read_csv(instrument_df_loc)
self.kite = kite
self.instrument_df = instrument_df
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"])
from kiteconnect import KiteConnect
import sys
import ssl
import configparser
ssl._create_default_https_context = ssl._create_unverified_context
config = configparser.ConfigParser()
config.read('kuber.conf')
login_conf = config['Login Configuration']
api_key = login_conf['api_key']
api_secret = login_conf['api_secret']
request_token = login_conf['request_token']
try:
kite = KiteConnect(api_key, api_secret)
except Exception as e:
print(e)
sys.exit(1)
try:
token = kite.request_access_token(request_token, api_secret)
except Exception as e:
print(e)
sys.exit(1)
config['ACCESS INFO'] = token
with open('kuber.conf', 'w') as configfile:
config.write(configfile)
import configparser
import webbrowser
# import urllib.request
# import urllib.response
ssl._create_default_https_context = ssl._create_unverified_context
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())
