def fetch_futures(futures, current_month_last_thurs, near_month_last_thurs,
fetched_futures, calcul_limit, option_lots):
future_status = {}
for future in futures:
stock_id = outil.get_stock_id(future[nse_bse.STOCK_ID])
future_status[stock_id] = {
'curr_mon_enable': True,
'near_mon_enable': True
}
future_cur_mon_symbol = outil.get_future_symbol(
stock_id, current_month_last_thurs)
future_near_mon_symbol = outil.get_future_symbol(
stock_id, near_month_last_thurs)
fetched_futures[future_cur_mon_symbol] = future_near_mon_symbol
fetched_futures[future_near_mon_symbol] = {
'ltp': None,
'liquid': False,
'c_ltp': None,
'c_liquid': False,
'c_symbol': future_cur_mon_symbol,
'sd_buy':
calcul_limit.calculated_calendar_spread_limits[stock_id][0],
'sd_sell':
calcul_limit.calculated_calendar_spread_limits[stock_id][1],
'lot': option_lots[stock_id],
'stock': stock_id
}
fetched_futures['future_status'] = future_status
fetched_futures['futures'] = futures
async def fetch_future_with_orderbook(stock_id, fetched_futures, last_thurs,
index):
bids, asks, ltp, spot = outil.get_all_bids(stock_id, last_thurs)
future = outil.Futures()
future.bids = bids
future.asks = asks
future.ltp = ltp
future.stock_id = stock_id
future.spot_price = spot
future.symbol = outil.get_future_symbol(stock_id, last_thurs)
fetched_futures.insert(index, future)
def pcr_null_illiquid_check(atm_option_call, atm_option_put, futures,
month_str):
if atm_option_call is None:
print('Null atm_option_call', month_str)
return False
if atm_option_call.liquidity is False or atm_option_call.volume is None or atm_option_call.volume <= 0:
print('Illiquid atm_option_call', month_str)
return False
if atm_option_put is None:
print('Null atm_option_put', month_str)
return False
if atm_option_put.liquidity is False or atm_option_put.volume is None or atm_option_put.volume <= 0:
print('Illiquid atm_option_put', month_str)
return False
if futures is None:
print('Null futures', month_str)
return False
if outil.is_instrument_liquid(futures.bids, futures.asks) is False:
print('Illiquid futures', month_str)
return False
return True
def set_pe_ce_data(options_data):
data = {}
first_row_excluded = False
for option_data in options_data:
if not first_row_excluded:
first_row_excluded = True
continue
curr_date = parser.parse(option_data[1].strip())
expiry_date = parser.parse(option_data[2].strip())
spot = bank_nifty_spot[curr_date]
last_thurs = outil.get_last_thurday_of_month(curr_date.month,
curr_date.year)
if curr_date.month != expiry_date.month or abs(
(expiry_date - last_thurs).days) > 1:
continue
strike = float(util.remove_non_no_chars(option_data[4].strip()))
if curr_date not in data:
data[curr_date] = {
'spot':
spot,
'atm_strike':
strike,
'prem_open':
float(util.remove_non_no_chars(option_data[5].strip())),
'prem_high':
float(util.remove_non_no_chars(option_data[6].strip())),
'prem_low':
float(util.remove_non_no_chars(option_data[7].strip())),
'prem_close':
float(util.remove_non_no_chars(option_data[8].strip())),
'buy_date':
curr_date,
'expiry_date':
expiry_date
}
elif abs(strike -
data[curr_date]['spot']) < abs(data[curr_date]['atm_strike'] -
data[curr_date]['spot']):
data[curr_date].update({
'atm_strike':
strike,
'prem_open':
float(util.remove_non_no_chars(option_data[5].strip())),
'prem_high':
float(util.remove_non_no_chars(option_data[6].strip())),
'prem_low':
float(util.remove_non_no_chars(option_data[7].strip())),
'prem_close':
float(util.remove_non_no_chars(option_data[8].strip()))
})
return data
def get_atm_call_puts(stock_id, last_thurs):
options = outil.get_all_strikes(stock_id, last_thurs.month,
last_thurs.year)
atm_strike = outil.get_atm_strike(options)
atm_option_call = None
atm_option_put = None
for option in options:
if option.strike_price == atm_strike:
if option.is_call:
atm_option_call = option
else:
atm_option_put = option
return atm_option_call, atm_option_put
def append_to_otm_strategy_response(stock_id, itm_option, otm_option, strategy_name, net_credit, net_debit,
stock_volatility):
if itm_option.implied_volatility is None:
itm_option.implied_volatility = 0
otm_strategy_responses.append(
[stock_id, strategy_name, itm_option.strike_price, otm_option.strike_price, itm_option.ltp, otm_option.ltp,
itm_option.spot_price, net_credit, net_debit, stock_volatility, itm_option.implied_volatility,
otm_option.implied_volatility, [1, 0][stock_volatility > itm_option.implied_volatility],
outil.is_stock_physically_settled(stock_id), option_lots[stock_id]])
def event_handler_quote_update(quote):
for order in orders_to_monitor:
if quote['symbol'] == order['symbol_to_track']:
if order['symbol_to_track_action'].value == Action.LONG.value and (
quote['ltp'] <= order['symbol_to_track_stoploss']
or quote['ltp'] >= order['symbol_to_track_target']):
dutil.sell_instrument(upstox_api, order['symbol_to_act'],
order['symbol_to_act_exch'], None,
order['lots'], OrderType.Market)
exit(0)
if order['symbol_to_track_action'].value == Action.SHORT.value and (
quote['ltp'] >= order['symbol_to_track_stoploss']
or quote['ltp'] <= order['symbol_to_track_target']):
dutil.buy_instrument(upstox_api, order['symbol_to_act'],
order['symbol_to_act_exch'], None,
order['lots'], OrderType.Market)
exit(0)
print(quote)
def try_short_pcr(upstox_api, atm_option_call, atm_option_put, future, lot,
max_earning):
net_premium = atm_option_call.ltp - atm_option_put.ltp + atm_option_call.strike_price - future.ltp
earning = net_premium * lot
if earning > max_earning[0]['earning']:
max_earning[0]['earning'] = earning
max_earning[0]['symbol_ltps'] = [
atm_option_call, atm_option_put, future
]
if earning > minimum_pcp_earning:
get_reduced_short_pcr_ltps(earning, atm_option_put, future,
atm_option_call, lot)
outil.buy_instrument(upstox_api, atm_option_put.symbol, nse_bse.NSE_FO,
atm_option_put.ltp, lot)
outil.buy_instrument(upstox_api, future.symbol, nse_bse.NSE_FO,
future.ltp, lot)
outil.sell_instrument(upstox_api, atm_option_call.symbol,
nse_bse.NSE_FO, atm_option_call.ltp, lot)
print('Executed SHORT PCR(CALL):', atm_option_call.symbol,
atm_option_call.ltp)
print('Executed SHORT PCR(PUT):', atm_option_put.symbol,
atm_option_put.ltp)
print('Executed SHORT PCR FUTURE:', future.symbol, future.ltp)
print('Earning:', earning)
# exit (0)
else:
print('Low earning:', earning)
def wait_and_buy_current_future(upstox_api, near_future, lots):
if util.check_if_instrument_in_positions(upstox_api, near_future['symbol'],
max_timeout_for_trade):
print('Sold', near_future['symbol'])
outil.buy_instrument(upstox_api, near_future['c_symbol'],
nse_bse.NSE_FO, near_future['c_ltp'], lots)
print('Executed future 0:', near_future['c_symbol'],
near_future['c_ltp'])
if util.check_if_instrument_in_positions(upstox_api,
near_future['c_symbol'],
max_timeout_for_trade):
print('Bought', near_future['c_symbol'])
else:
util.cancel_order(upstox_api, near_future['c_symbol'])
print('Time out for buying future 0', near_future['c_symbol'])
outil.buy_instrument(upstox_api, near_future['symbol'],
nse_bse.NSE_FO, near_future['ltp'] - 1, lots)
exit(0)
else:
util.cancel_order(upstox_api, near_future['symbol'])
print('Time out for buying future 1', near_future['symbol'])
async def fetch_futures(futures, fetched_futures, current_month_last_thurs_yr,
near_month_last_thurs_mn, far_month_last_thurs_mn):
tasks = []
for future in futures:
stock_id = outil.get_stock_id(future[nse_bse.STOCK_ID])
tasks.append(
asyncio.ensure_future(
fetch_future(stock_id, fetched_futures,
current_month_last_thurs_yr,
near_month_last_thurs_mn,
far_month_last_thurs_mn)))
await asyncio.gather(*tasks)
def check_pcr_future(future):
if future is None:
print('Null futures', future.symbol)
return False
if outil.is_instrument_liquid(future.bids, future.asks) is False:
print('Illiquid futures', future.symbol)
return False
if future.volume is None or future.volume <= 0 or future.high is None or future.high <= 0 or future.low is None or future.low <= 0 or future.open is None or future.open <= 0:
print('Illiquid futures', future.symbol)
return False
return True
otm = {'strike': None, 'start_date': None}
spot_start_of_month = None
for option_data in options_data:
if not first_row_excluded:
first_row_excluded = True
continue
curr_date = parser.parse(option_data[1].strip())
expiry_date = parser.parse(option_data[2].strip())
if spot_start_of_month is None:
spot_start_of_month = float(
util.remove_non_no_chars(option_data[16].strip()))
last_thurs = outil.get_last_thurday_of_month(
curr_date.month, curr_date.year)
if curr_date.month != expiry_date.month or abs(
(expiry_date - last_thurs).days) > 1:
continue
strike = float(util.remove_non_no_chars(
option_data[4].strip()))
if otm['start_date'] is None or otm['start_date'] >= curr_date:
if strike > spot_start_of_month and (
otm['strike'] is None or
(strike - spot_start_of_month) <
(otm['strike'] - spot_start_of_month)):
otm = {
'strike':
start_date = datetime.now() - timedelta(days=diff_between_start_end_date)
end_date = datetime.now() - timedelta(days=1)
futures = []
# futures = nse_bse.get_all_nse_stocks_ids ()
indices = nse_bse.get_indices()
# futures = nse_bse.get_nse_fo_stocks ()
futures.extend(indices)
futures = [{nse_bse.STOCK_ID: 'SBIN', nse_bse.EXCHANGE: nse_bse.NSE_FO}]
cs_responses = []
option_lots = nse_bse.get_nse_fo_lots()
for future in futures:
try:
stock_id = outil.get_stock_id(future[nse_bse.STOCK_ID])
future_current_month_historical_data = []
future_near_month_historical_data = []
future_far_month_historical_data = []
util.get_future_historical_data(stock_id,
future_current_month_historical_data,
future_near_month_historical_data,
future_far_month_historical_data)
future_near_month_historical_data = util.get_equity_historical_data(
stock_id)
current_near_months_diffs = c_spread.check_get_calendar_spread_month_diffs(
future_current_month_historical_data,
future_near_month_historical_data)
def isliquid(bids):
if bids is None or len(bids) == 0:
return False
for bid in bids:
if bid['price'] is None or bid['price'] is 0 or bid[
'quantity'] is None or bid['quantity'] is 0:
return False
return True
kite = util.intialize_kite_api()
current_month_last_thurs = outil.get_last_thurday_of_month(
datetime.now().month,
datetime.now().year)
near_month_last_thurs = current_month_last_thurs + relativedelta(months=+1)
fo_stocks = sUtils.get_nse_fo_stocks()
lots = sUtils.get_nse_fo_lots()
nse_futures = []
for fo_stock in fo_stocks:
stock_id = fo_stock[sUtils.STOCK_ID]
nse_futures.append(
util.NFO + outil.get_future_symbol(stock_id, current_month_last_thurs))
nse_futures.append(
util.NFO + outil.get_future_symbol(stock_id, near_month_last_thurs))
start_time = time.time ()
# futures = nse_bse.get_all_nse_stocks_ids ()
# indices = nse_bse.get_indices ()
futures = nse_bse.get_nse_fo_stocks ()
# futures.extend (indices)
# futures = nse_bse.get_indices ()
# futures = nse_bse.get_nifty50_stocks_latest_info ()
# futures = nse_bse.get_nifty100_stocks_latest_info ()
# futures = [{nse_bse.STOCK_ID: 'TATAPOWER', nse_bse.EXCHANGE: nse_bse.NSE_FO}]
# futures.extend(indices)
future_limits = {}
for future in futures:
try:
stock_id = outil.get_stock_id (future[nse_bse.STOCK_ID])
future_current_month_historical_data = []
future_near_month_historical_data = []
future_far_month_historical_data = []
util.get_future_historical_data (stock_id, future_current_month_historical_data,
future_near_month_historical_data, future_far_month_historical_data)
future_near_month_historical_data = util.get_equity_historical_data (stock_id)
current_near_months_diffs = c_spread.check_get_calendar_spread_month_diffs (
future_current_month_historical_data, future_near_month_historical_data)
current_far_months_diffs = c_spread.check_get_calendar_spread_month_diffs (future_current_month_historical_data,
future_far_month_historical_data)
[nse_bse.NSE_FO, nse_bse.NSE, nse_bse.NSE_INDEX])
today_date = datetime.today().date()
start_date = datetime.now() - timedelta(days=diff_between_start_end_date)
end_date = datetime.now() - timedelta(days=1)
# stocks_latest_info = nse_bse.get_all_nse_stocks_ids ()
indices = nse_bse.get_indices()
stocks_latest_info = nse_bse.get_nse_fo_stocks()
stocks_latest_info.extend(indices)
# stocks_latest_info = nse_bse.get_indices ()
# stocks_latest_info = nse_bse.get_nifty50_stocks_latest_info ()
# stocks_latest_info = nse_bse.get_nifty100_stocks_latest_info ()
# stocks_latest_info = [{nse_bse.STOCK_ID: 'JETAIRWAYS', nse_bse.EXCHANGE: nse_bse.NSE_INDEX}]
last_thurs = outil.get_last_thurday_of_month(today_date.month, today_date.year)
no_of_days_till_last_thurs = last_thurs.day - today_date.day + 1
required_margins = outil.get_future_margins(stocks_latest_info)
if util.is_market_open():
available_margin = upstox_api.get_balance()['equity']['available_margin']
stocks_latest_info[:] = [
x for x in stocks_latest_info
if required_margins[outil.get_stock_id(x[nse_bse.STOCK_ID])] <= (
.95 * available_margin)
]
option_lots = nse_bse.get_nse_fo_lots()
today = datetime.date.today()
for stock in tradable_stocks:
last = today
first = last - datetime.timedelta(days=365)
try:
while first.year != 2014:
first_day = first.strftime("%d-%m-%Y")
last_day = last.strftime("%d-%m-%Y")
last = first - datetime.timedelta(days=1)
first = last - datetime.timedelta(days=365)
stock_id = urllib.parse.quote(outil.get_stock_id(stock))
option_file = FILES_LOCATION + '_' + urllib.parse.unquote(stock_id) + '_' + first_day + '_' + last_day + outil.EQ_FILE_SUFFIX
if os.path.exists (option_file):
print (stock_id + ' data already exists.')
continue
# url = NSE_EQ_HIST_DATA_URL.format(stock_id, period)
url = NSE_EQ_HIST_DATA_URL.format(stock_id, first_day, last_day)
response = requests.get(url, headers=outil.FUTURE_HEADERS)
# parse the html using beautiful soup and store in variable `soup`
soup = BeautifulSoup(response.text, 'html.parser')
option_data = soup.findAll('div', attrs={'id': 'csvContentDiv'})
if option_data is not None and len(option_data) > 0:
import Utils as util
from dateutil.relativedelta import relativedelta
minimum_cs_earning = 6500
minimum_pcp_earning = 20000
max_timeout_for_trade = 180
cs_earning_sacrifical_ratio = .2
pcr_earning_sacrifical_ratio = .2
max_std_multiple_for_buy = 2
max_std_multiple_for_sell = 1
future_liquidity_margin = .1
min_no_of_bids_asks = 5
today_date = datetime.today().date()
current_month_last_thurs = outil.get_last_thurday_of_month(
today_date.month, today_date.year)
near_month_last_thurs = current_month_last_thurs + relativedelta(months=+1)
def fetch_futures(futures, current_month_last_thurs, near_month_last_thurs,
fetched_futures, calcul_limit, option_lots):
future_status = {}
for future in futures:
stock_id = outil.get_stock_id(future[nse_bse.STOCK_ID])
future_status[stock_id] = {
'curr_mon_enable': True,
'near_mon_enable': True
}
future_cur_mon_symbol = outil.get_future_symbol(
# stocks_latest_info = nse_bse.get_all_nse_stocks_ids ()
indices = nse_bse.get_indices ()
stocks_latest_info = nse_bse.get_nse_fo_stocks ()
stocks_latest_info.extend (indices)
# stocks_latest_info = nse_bse.get_indices()
# stocks_latest_info = nse_bse.get_nifty50_stocks_latest_info ()
# stocks_latest_info = nse_bse.get_nifty100_stocks_latest_info ()
#stocks_latest_info = [{nse_bse.STOCK_ID: 'NIFTY_BANK', nse_bse.EXCHANGE: nse_bse.NSE_INDEX}]
otm_contract_responses = []
option_lots = nse_bse.get_nse_fo_lots()
for stock_latest_info in stocks_latest_info:
stock_id = outil.get_stock_id(stock_latest_info[nse_bse.STOCK_ID])
option_hist_data = []
with open(outil.OPTION_FILE_LOCATION + stock_id + outil.OPTION_FILE_SUFFIX) as csvfile:
options_data = csv.reader(csvfile, delimiter=',', quotechar='"')
row_count = 0
for option_data in options_data:
if row_count > 0:
close = 0
if util.is_number (util.remove_non_no_chars (option_data[8].strip ())):
close = float (util.remove_non_no_chars (option_data[8].strip ()))
else:
print ('Fetching prev close', stock_id, option_data)
close = option_hist_data[-1]['close']
import Utils as util
diff_between_start_end_date = 365
min_return_monthly = 10
no_of_sessions_to_scan_for_volatility = pr.no_of_sessions_to_scan_for_volatility
current_time = time.strftime("%Y_%m_%d#%H_%M_%S")
high_volat_options_excel_location = 'F:/Trading_Responses/High_Volat_Option_excel_' + str(
current_time) + '.xlsx'
start_time = time.time()
today_date = datetime.today().date()
start_date = datetime.now() - timedelta(days=diff_between_start_end_date)
end_date = datetime.now() - timedelta(days=1)
last_thurs = outil.get_last_thurday_of_month(today_date.month, today_date.year)
no_of_days_till_last_thurs = last_thurs.day - today_date.day + 1
upstox_api = util.intialize_upstox_api(
[nse_bse.NSE_FO, nse_bse.NSE, nse_bse.NSE_INDEX])
# stocks_latest_info = nse_bse.get_all_nse_stocks_ids ()
indices = nse_bse.get_indices()
stocks_latest_info = nse_bse.get_nse_fo_stocks()
stocks_latest_info.extend(indices)
# stocks_latest_info = nse_bse.get_indices ()
# stocks_latest_info = nse_bse.get_nifty50_stocks_latest_info ()
# stocks_latest_info = nse_bse.get_nifty100_stocks_latest_info ()
# stocks_latest_info = [{nse_bse.STOCK_ID: 'BHEL', nse_bse.EXCHANGE: nse_bse.NSE}]
def get_calendar_spread_responses(option_lots,
stock_id,
current_month_last_thurs,
near_month_last_thurs,
far_month_last_thurs,
futures,
margin,
debug=True):
cs_responses = []
future_current_month_symbol = outil.get_future_symbol(
stock_id, current_month_last_thurs)
future_near_month_symbol = outil.get_future_symbol(stock_id,
near_month_last_thurs)
future_far_month_symbol = outil.get_future_symbol(stock_id,
far_month_last_thurs)
current_near_months_range_upper_limit_for_buy = calcul_limit.calculated_calendar_spread_limits[
stock_id][0]
current_near_months_range_upper_limit_for_sell = calcul_limit.calculated_calendar_spread_limits[
stock_id][1]
current_far_months_range_upper_limit_for_buy = calcul_limit.calculated_calendar_spread_limits[
stock_id][2]
current_far_months_range_upper_limit_for_sell = calcul_limit.calculated_calendar_spread_limits[
stock_id][3]
if current_near_months_range_upper_limit_for_buy is None or current_far_months_range_upper_limit_for_buy is None:
print('No limits for stock:' + stock_id)
return []
if len(futures) > 1:
if futures[0].ltp is not None and futures[0].ltp is not 0:
if futures[1].ltp is not None and futures[1].ltp is not 0:
spread = futures[1].ltp - futures[0].ltp
if spread > current_near_months_range_upper_limit_for_buy:
# if True:
cs_responses.append([
future_current_month_symbol, future_near_month_symbol,
futures[1].ltp, futures[0].ltp,
current_near_months_range_upper_limit_for_buy,
current_near_months_range_upper_limit_for_sell, spread,
spread / current_near_months_range_upper_limit_for_buy,
(spread -
current_near_months_range_upper_limit_for_sell) *
option_lots[stock_id], margin, option_lots[stock_id]
])
else:
if debug:
print('No ltp for future:' + str(futures[1]))
if len(futures) > 2:
if futures[2].ltp is not None and futures[2].ltp is not 0:
spread = futures[2].ltp - futures[0].ltp
if spread > current_far_months_range_upper_limit_for_buy:
# if True:
cs_responses.append([
future_current_month_symbol,
future_far_month_symbol, futures[2].ltp,
futures[0].ltp,
current_far_months_range_upper_limit_for_buy,
current_far_months_range_upper_limit_for_sell,
spread, spread /
current_far_months_range_upper_limit_for_buy,
(spread -
current_far_months_range_upper_limit_for_sell) *
option_lots[stock_id], margin,
option_lots[stock_id]
])
else:
if debug:
print('No ltp for future:' + str(futures[2]))
else:
if debug:
print(*futures, 'No futures:')
else:
if debug:
print('No ltp for future:' + str(futures[0]))
else:
if debug:
print(*futures, 'No futures:')
return cs_responses
import DerivativeUtils as outil
import ScrapUtils as sutils
from bs4 import BeautifulSoup
period = '12month'
# period = '24month'
NSE_FUTURE_HIST_DATA_URL = 'https://www.nseindia.com/products/dynaContent/common/productsSymbolMapping.jsp?instrumentType={0}&symbol={1}&expiryDate=select&optionType=select&strikePrice=&dateRange={2}&fromDate=&toDate=&segmentLink=9&symbolCount='
futures = []
# indices = sutils.get_indices()
futures = sutils.get_nse_fo_stocks()
# futures.extend(indices)
# futures = [{sutils.STOCK_ID: 'SBIN', sutils.EXCHANGE: sutils.NSE_FO}]
for future in futures:
try:
stock_id = outil.get_stock_id(future[sutils.STOCK_ID])
stock_id = urllib.parse.quote(stock_id)
if stock_id == sutils.NIFTY_50_NSE_SYMBOL:
url = NSE_FUTURE_HIST_DATA_URL.format(outil.FUTIDX, stock_id,
period)
elif stock_id == sutils.NIFTY_BANK_NSE_SYMBOL:
url = NSE_FUTURE_HIST_DATA_URL.format(outil.FUTIDX, stock_id,
period)
else:
url = NSE_FUTURE_HIST_DATA_URL.format(outil.FUTSTK, stock_id,
period)
page = urlopen(Request(url, headers=outil.FUTURE_HEADERS))
# parse the html using beautiful soup and store in variable `soup`
soup = BeautifulSoup(page, 'html.parser')
NSE_EQ_HIST_DATA_URL = 'https://www1.nseindia.com/products/dynaContent/common/productsSymbolMapping.jsp?symbol={0}&segmentLink=3&symbolCount=2&series=EQ&dateRange=12month&fromDate=&toDate=&dataType=PRICEVOLUMEDELIVERABLE'
# stocks = sutils.get_nse_fo_stocks()
# indices = sutils.get_indices()
tradable_stocks = scrap.get_nse_fo_stocks()
# tradable_stocks = sutils.get_all_nse_stocks_ids()
# tradable_stocks = sutils.get_tradable_stocks_ids()
# top_20_traded_stocks = sutils.get_top_20_nse_traded_stocks(tradable_stocks)
# tradable_stocks.extend(top_20_traded_stocks)
# stocks.extend(indices)
# stocks = [{sutils.STOCK_ID: 'ESCORTS', sutils.EXCHANGE: sutils.NSE_FO}]
for stock in tradable_stocks:
try:
stock_id = sutils.get_stock_id(stock[scrap.STOCK_ID])
# stock_id = urllib.parse.quote(stock_id)
# if stock_id == 'NBVENTURES':
# start = True
#
# if not start:
# continue
option_file = sutils.EQ_FILE_LOCATION + urllib.parse.unquote (stock_id) + sutils.EQ_FILE_SUFFIX
if os.path.exists (option_file):
print (stock_id + ' option data already exists.')
continue
url = NSE_EQ_HIST_DATA_URL.format(stock_id)
upstox_api = util.intialize_upstox_api([nse_bse.NSE_FO, nse_bse.NSE])
# upstox_api = None
# futures = nse_bse.get_all_nse_stocks_ids ()
futures = nse_bse.get_nse_fo_stocks()
# futures = nse_bse.get_indices ()
# futures = nse_bse.get_nifty50_stocks_latest_info ()
# futures = nse_bse.get_nifty100_stocks_latest_info ()
futures = [{nse_bse.STOCK_ID: 'IBULHSGFIN', nse_bse.EXCHANGE: nse_bse.NSE_FO}]
fetched_futures = {}
symbols_to_subscribe = []
today_date = datetime.today().date()
current_month_last_thurs = d_util.get_last_thurday_of_month(today_date.month, today_date.year)
near_month_last_thurs = current_month_last_thurs + relativedelta(months=+1)
for future in futures:
stock_id = d_util.get_stock_id(future[nse_bse.STOCK_ID])
future_cur_mon_symbol = d_util.get_future_symbol(stock_id, current_month_last_thurs)
future_near_mon_symbol = d_util.get_future_symbol(stock_id, near_month_last_thurs)
near_future = upstox_api.get_instrument_by_symbol(nse_bse.NSE_FO, future_near_mon_symbol)
curr_future = upstox_api.get_instrument_by_symbol(nse_bse.NSE_FO, future_cur_mon_symbol)
if near_future is not None and curr_future is not None:
symbols_to_subscribe.append(curr_future)
symbols_to_subscribe.append(near_future)
import DerivativeUtils as dutil
import ScrapUtils as nse_bse
import Utils as util
start_time = time.time()
upstox_api = util.intialize_upstox_api([nse_bse.NSE])
max_bearable_loss = 3000
max_limit_sacrifice = 400
orders = []
today_date = datetime.today().date()
last_thurs = dutil.get_last_thurday_of_month(today_date.month, today_date.year)
# future_lots = dutil.get_nse_fo_lots_on_future(last_thurs)
future_lots = nse_bse.get_nse_fo_lots()
PRICE_DIFF = 'price_diff'
max_price_rise_wrt_today = {nse_bse.STOCK_ID: None, PRICE_DIFF: -math.inf}
max_price_fall_wrt_today = {nse_bse.STOCK_ID: None, PRICE_DIFF: math.inf}
def update_prices(stock_id, ltp, open):
price_change_wrt_today = (ltp - open) / open
if price_change_wrt_today > 0 and price_change_wrt_today > max_price_rise_wrt_today[
PRICE_DIFF]:
max_price_rise_wrt_today[nse_bse.STOCK_ID] = stock_id
max_price_rise_wrt_today[PRICE_DIFF] = price_change_wrt_today
elif price_change_wrt_today < 0 and price_change_wrt_today < max_price_fall_wrt_today[
today_date = datetime.today().date()
start_date = datetime.now() - timedelta(days=diff_between_start_end_date)
end_date = datetime.now() - timedelta(days=1)
no_of_sessions_to_scan_for_volatility = pr.no_of_sessions_to_scan_for_volatility
# stocks_latest_info = nse_bse.get_all_nse_stocks_ids ()
indices = nse_bse.get_indices()
stocks_latest_info = nse_bse.get_nse_fo_stocks()
stocks_latest_info.extend(indices)
# stocks_latest_info = nse_bse.get_indices ()
# stocks_latest_info = nse_bse.get_nifty50_stocks_latest_info ()
# stocks_latest_info = nse_bse.get_nifty100_stocks_latest_info ()
# stocks_latest_info = [{nse_bse.STOCK_ID: 'HDFC', nse_bse.EXCHANGE: nse_bse.NSE}]
last_thurs = outil.get_last_thurday_of_month(today_date.month, today_date.year)
fetched_options = {}
outil.run_fetch_options(stocks_latest_info, fetched_options, today_date)
fetched_stocks_data = {}
stocks_data_obj = pickle.load(open(util.STOCK_DATA_OBJ_FILE, 'rb'))
upstox_api = util.intialize_upstox_api([nse_bse.NSE_FO, nse_bse.NSE, nse_bse.NSE_INDEX])
util.run_fetch_stocks_data(stocks_latest_info, fetched_stocks_data, upstox_api, start_date, end_date, stocks_data_obj,
False)
otm_strategy_responses = []
option_lots = nse_bse.get_nse_fo_lots()
def append_to_otm_strategy_response(stock_id, itm_option, otm_option, strategy_name, net_credit, net_debit,
async def fetch_future(stock_id, fetched_futures, current_month_last_thurs_yr,
near_month_last_thurs_mn, far_month_last_thurs_mn):
fetched_futures[stock_id] = outil.get_all_futures(
stock_id, current_month_last_thurs_yr, near_month_last_thurs_mn,
far_month_last_thurs_mn)
import traceback
import urllib.parse
import GenericStatPrinter as gstats
import DerivativeUtils as outil
import TradingScripts.ScrapUtils as sutils
import TradingScripts.Utils as util
import os
from datetime import datetime
stocks = sutils.get_nse_fo_stocks()
nse_fo_stocks = []
for stock in stocks:
stock_id = urllib.parse.quote (outil.get_stock_id (stock[sutils.STOCK_ID]))
nse_fo_stocks.append(stock_id)
today_date = datetime.now ().strftime ('%Y-%m-%d')
excel_location = ['G:', 'F:'][os.path.exists('F:')] + '/Trading_Responses/TradableStocks_' + str (today_date) + '.xlsx'
stocks = sutils.get_all_nse_stocks_ids()
# stocks = sutils.get_nse_fo_stocks()
# stocks = [{sutils.STOCK_ID: 'ASIANPAINT'}]
max_duration_to_consider = 180
min_daily_order_size = 500000
stock_market_cap = {}
for stock in stocks:
try:
stock_id = outil.get_stock_id(stock[sutils.STOCK_ID])
stock_id = urllib.parse.quote(stock_id)
def set_pe_ce_data(options_data):
data = {}
first_row_excluded = False
spot_start_of_month = None
spot_at_expiry = None
for option_data in options_data:
if not first_row_excluded:
first_row_excluded = True
continue
curr_date = parser.parse(option_data[1].strip())
expiry_date = parser.parse(option_data[2].strip())
if spot_start_of_month is None:
spot_start_of_month = get_bank_nifty_spot(curr_date)
last_thurs = outil.get_last_thurday_of_month(curr_date.month,
curr_date.year)
if curr_date.month != expiry_date.month or abs(
(expiry_date - last_thurs).days) > 1:
continue
if spot_at_expiry is None:
spot_at_expiry = get_bank_nifty_spot(expiry_date)
strike = float(util.remove_non_no_chars(option_data[4].strip()))
if 'expiry_date' not in data:
data = {
'spot':
spot_start_of_month,
'spot_at_expiry':
spot_at_expiry,
'atm_strike':
strike,
'prem_buy':
float(util.remove_non_no_chars(option_data[5].strip())),
'buy_date':
curr_date,
'expiry_date':
expiry_date,
'dates': {},
'prem_buy_high':
float(util.remove_non_no_chars(option_data[6].strip())),
'prem_buy_low':
float(util.remove_non_no_chars(option_data[7].strip())),
'prem_buy_close':
float(util.remove_non_no_chars(option_data[8].strip()))
}
elif abs(strike - data['spot']) < abs(
data['atm_strike'] -
data['spot']) and curr_date <= data['buy_date']:
data.update({
'atm_strike':
strike,
'prem_buy':
float(util.remove_non_no_chars(option_data[5].strip())),
'buy_date':
curr_date,
'prem_buy_high':
float(util.remove_non_no_chars(option_data[6].strip())),
'prem_buy_low':
float(util.remove_non_no_chars(option_data[7].strip())),
'prem_buy_close':
float(util.remove_non_no_chars(option_data[8].strip()))
})
if expiry_date == curr_date and data['atm_strike'] == strike:
data.update({
'exit_premium':
float(util.remove_non_no_chars(option_data[8].strip())),
'exit_premium_high':
float(util.remove_non_no_chars(option_data[6].strip())),
'exit_premium_low':
float(util.remove_non_no_chars(option_data[7].strip())),
'exit_premium_open':
float(util.remove_non_no_chars(option_data[5].strip()))
})
if data['atm_strike'] == strike and curr_date != data[
'buy_date'] and curr_date != data['expiry_date']:
data['dates'].update({
curr_date: {
'prem_open':
float(util.remove_non_no_chars(option_data[5].strip())),
'prem_high':
float(util.remove_non_no_chars(option_data[6].strip())),
'prem_low':
float(util.remove_non_no_chars(option_data[7].strip())),
'prem_close':
float(util.remove_non_no_chars(option_data[8].strip()))
}
})
return data
# stocks_latest_info = nse_bse.get_all_nse_stocks_ids ()
# indices = nse_bse.get_indices ()
stocks_latest_info = nse_bse.get_nse_fo_stocks()
# stocks_latest_info.extend (indices)
# stocks_latest_info = nse_bse.get_indices ()
# stocks_latest_info = nse_bse.get_nifty50_stocks_latest_info ()
# stocks_latest_info = nse_bse.get_nifty100_stocks_latest_info ()
# stocks_latest_info = [{nse_bse.STOCK_ID: 'HDFCBANK', nse_bse.EXCHANGE: nse_bse.NSE}]
pcr_responses = []
option_lots = nse_bse.get_nse_fo_lots()
for stock_latest_info in stocks_latest_info:
try:
stock_id = outil.get_stock_id(stock_latest_info[nse_bse.STOCK_ID])
option_ce_hist_data = []
with open(outil.OPTION_FILE_LOCATION + stock_id + 'CE' +
outil.OPTION_FILE_SUFFIX) as csvfile:
options_data = csv.reader(csvfile, delimiter=',', quotechar='"')
row_count = 0
for option_data in options_data:
if row_count > 0:
close = 0
if util.is_number(
util.remove_non_no_chars(option_data[8].strip())):
close = float(
util.remove_non_no_chars(option_data[8].strip()))
else: