class Utility:
def __init__(self):
self.nse = Nse()
def CheckStockCode(self, stock):
return self.nse.is_valid_code(stock)
def GetAllDetailsOfStock(self, stock):
return self.nse.get_quote(str(stock))
def GetAllAttrNamesOfStock(self, stock):
return self.nse.get_quote(stock).keys()
def CheckAttrNamesOfStock(self, stock, attrnames):
ret = self.GetAllDetailsOfStock(stock)
if set(attrnames).issubset(set(ret.keys())):
return True
else:
return False
def CheckAttrTypesOfStock(self, stock, attrnames, attrtypes, attrvalues):
ret = self.GetAllDetailsOfStock(stock)
flag = False
for i in range(len(attrtypes)):
if str(attrtypes[i]) == 'date':
try:
parse(ret[attrnames[i]])
parse(str(attrvalues[i]))
flag = True
except:
flag = False
break
elif str(attrtypes[i]) == 'number':
try:
float(ret[attrnames[i]])
float(str(attrvalues[i]))
flag = True
except:
flag = False
break
else:
flag = True
return flag
def CheckOperation(self, attrtype, operation):
if attrtype == 'string' and operation != 'equals':
return False
else:
return True
class getQuotes:
def __init__(self, symbol):
self.nse = Nse()
self.symbol = symbol
self.stocknamelist = []
self.closepricelist = []
self.yearhighlist = []
self.yearlowlist = []
def run(self):
import requests
requests.packages.urllib3.disable_warnings()
import ssl
try:
_create_unverified_https_context = ssl._create_unverified_context
except AttributeError:
pass
else:
ssl._create_default_https_context = _create_unverified_https_context
for i in self.symbol:
q = self.nse.get_quote(i)
closedprice = q.get("averagePrice")
self.closepricelist.append(closedprice)
companyName = q.get("companyName")
self.stocknamelist.append(companyName)
yearlyhigh = q.get("high52")
self.yearhighlist.append(yearlyhigh)
yearlylow = q.get("low52")
self.yearlowlist.append(yearlylow)
def nse_stock_current_data(symbol):
try:
nse = Nse()
print("Collecting Current Stock Data", "-" * 80)
print("date and time: ", datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
stock = nse.get_quote(symbol)
print("date and time: ", datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
print("Current Stock Data Collected", "-" * 80)
stock_price = {
"date":
"{}-{}-{}".format(date.today().day,
date.today().month,
date.today().year),
"price":
stock['lastPrice'],
}
return Response(mimetype="application/json",
response=json.dumps(stock_price),
status=200)
except Exception as e:
error_msg = get_error_msg(e)
logger.error(error_msg)
return Response(mimetype="application/json",
response=json.dumps({'error': error_msg}),
status=400)
def get_nse100_data(stock_dict=stock_dict):
stocks_dict = {}
nse = Nse()
stock_parameters = [
'dayHigh', 'dayLow', 'open', 'lastPrice', 'pChange',
'totalTradedVolume'
]
for i, stock in enumerate(stock_dict.keys(), 1):
print(i, stock)
stock_details = nse.get_quote(stock, as_json=True)
stocks_dict.setdefault(stock, [])
for i, parameter in enumerate(stock_parameters):
stocks_dict[stock].append(json.loads(stock_details)[parameter])
df = pd.DataFrame.from_dict(stocks_dict,
orient='index',
columns=[
'HIGH', 'LOW', 'OPEN', 'LAST TRADED PRICE',
'%change', 'TOTAL TRADED VOLUME'
])
df.reset_index(inplace=True)
df.rename(columns={'index': 'symbol'}, inplace=True)
minute = time.ctime().split(':')[1]
file_name = 'data.csv'
file_name = minute + '_' + file_name
path = './vwap_data/' + file_name
df.to_csv(path, index=False)
return df
def watchlist(request):
investedtot = 0
currentval = 0
pltot = 0
returnper = 0
#stock_list = nse_m_stocklist.objects.exclude(stock_type = 'PL')
stock_list = nse_m_stocklist.objects.filter(stock_type='WL')
for stock in stock_list:
stockprice = 0
nse = Nse()
try:
q = nse.get_quote(stock.stock_code)
for price in q.items():
if price[0] == 'lastPrice':
stockprice = price[1]
break
except:
stockprice = 0
stock.currprice = stockprice
stock.save()
# table_data = nse_m_stocklist.objects.exclude(stock_type = 'PL')
table_data = nse_m_stocklist.objects.filter(stock_type='WL')
table = nse_t_watchlist(table_data)
RequestConfig(request).configure(table)
context = {'table': table}
return render(request, 'nse/watchlist.html', context)
def stockInfo():
name = ""
price = ""
symbol = ""
exchange = input("Enter I for NSE and A for NASDAQ: ")
symbol = input("Enter brand symbol: ")
if "I" in exchange or "i" in exchange:
nse = Nse()
quote = nse.get_quote(symbol)
price = (quote['basePrice'])
price = "INR " + str(price)
name = quote['companyName']
elif "A" in exchange or "a" in exchange:
name = yf.Ticker(symbol)
name = (name.info['longName'])
price = stock_info.get_live_price(symbol)
price = "USD " + str(price)
else:
print("Error")
print("Name : " + name)
print("Symbol : " + symbol)
print("Price : " + price)
update_histroy(("checked stock info for"+name))
def home(request):
# in home we are going to create a request to make connection with an API
import requests # get data from internet source # pip install requests in Git Bash
import json # java script object notation for parsing the requested data
# return render(request, 'home.html',{})
if request.method == 'POST':
ticker = request.POST['ticker']
#tick_val = nse.is_valid_code(ticker)
#if (nse.is_valid_code(ticker)):
from nsetools import Nse
nse = Nse()
api_request = nse.get_quote(ticker)
try: #api = json.loads(api_request.content) # parsing the requested data
api = api_request
except Exception as e:
api = 'Error...'
return render(request, 'home.html', {'api': api})
#else:
# return render(request, 'home.html',{'ticker':"Enter a Ticker"})
else:
return render(request, 'home.html', {'ticker': "Enter a Ticker"})
def stocks(request):
import requests # get data from internet source # pip install requests in Git Bash
import json # java script object notation for parsing the requested data
from nsetools import Nse
if request.method == 'POST':
form = StockForm(request.POST or None)
if form.is_valid():
form.save()
messages.success(request, ("stock added"))
return redirect('stocks')
else:
nse = Nse()
ticker = stock.objects.all()
output = []
for ticker_item in ticker:
api_request = nse.get_quote(
str(ticker_item)) # need to pass as String, otherwise error
try: #api = json.loads(api_request.content) # parsing the requested data
api = api_request
output.append(api)
except Exception as e:
api = 'Error...'
return render(request, 'stocks.html', {
'ticker': ticker,
'output': output
})
def do(self):
CommonCronJob.logger.info("Going to run stock rate updater cron")
cnt = 0
stocks = Stock.objects.all()
currency = Currency.objects.filter(is_default=True).first()
nse = Nse()
try:
with transaction.atomic():
models_to_create = []
for stock in stocks:
cnt += 1
try:
quote = nse.get_quote(stock.code)
time.sleep(.300)
stock_rate = StockRate(code=stock.code, stock=stock,
rate=quote['basePrice'], currency=currency,
last_updated_on=timezone.now())
models_to_create.append(stock_rate)
CommonCronJob.logger.info("Completed for {0} - {1}".format(cnt, stock))
except Exception as er:
CommonCronJob.logger.error("Error for {0} - {1} - {2}".format(cnt, stock, er))
StockRate.objects.all().delete()
StockRate.objects.bulk_create(models_to_create)
CommonCronJob.logger.info("Completed stock rate updater cron")
except URLError:
CommonCronJob.logger.error("Unable to connect to nse")
except DatabaseError:
CommonCronJob.logger.error("Database error")
except Exception as e:
CommonCronJob.logger.error("Error happened")
class NSE(Stock):
STOCK_EXCHANGE_CODE = 'NSE'
def __init__(self):
self.nse = Nse()
super(NSE, self).__init__()
def perform_latest(self, code):
stock_dict = self.nse.get_quote(str(code))
if stock_dict is None:
# cannot rely on quandl apis coz it has some api limits
self.use_default_transform = True
return super(NSE, self).perform_latest(code)
return stock_dict
def transform(self, data):
return {
"date": data['cm_adj_low_dt'],
"open": data['open'],
"high": data['dayHigh'],
"low": data['dayLow'],
"last": data['lastPrice'],
"close": data['previousClose'],
"totalTradeQuantity": data['quantityTraded'],
"turnover": None,
"refreshedAt": helper.now()
}
def GetPriceSymbol( ):
nse = Nse()
with open(r'C:\\Migration\\EagleEye\\Master\\Trading_Mast_zone2.csv',"r") as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
#next(csv_reader)
for lines in csv_reader:
print("The symbol processing is",lines[0])
q = nse.get_quote(lines[0].strip())
parsed_json = json.loads(json.dumps(q))
l_lastprice=parsed_json['lastPrice']
#print("The last price is ",l_lastprice)
l_averagePrice=parsed_json['averagePrice']
#print("The average price is ",l_averagePrice)
l_totaltradedvolume=parsed_json['totalTradedVolume']
#print("The total traded volume is ",l_totaltradedvolume)
l_max_price_n=parsed_json['dayHigh']
#print("The max price for the symbol ",l_max_price_n)
l_min_price_n=parsed_json['dayLow']
#print("The min price for the symbol ",l_min_price_n)
l_open_price_n=parsed_json['open']
#print("The open price for the symbol ",l_open_price_n)
con = cx_Oracle.connect('EQUITY/EQUITY@localhost/XE')
cur = con.cursor()
cur.execute("INSERT INTO daily_nse_movement_trans (symbol,lastprice_n,last_avg_price_n,totaltradedvol_n,max_price_n,min_price_n,open_price_n) VALUES (:1,:2,:3,:4,:5,:6,:7)" ,(lines[0].strip(),l_lastprice, l_averagePrice,l_totaltradedvolume,l_max_price_n,l_min_price_n,l_open_price_n))
statement = 'DELETE FROM daily_nse_movement_trans WHERE EXCEPTION_FLAG_V=:type'
cur.execute(cur.execute(statement, {'type':'Y'}))
cur.close()
con.commit()
#print("End of the loop ---")
con.close()
def ioc():
keyword = '$IOC'
stockSymbol = 'IOC'
my_result = fetch(keyword, stockSymbol)
predicted_value = my_result[0]
trend = my_result[1]
if (trend == 'Downtrend'):
sentimentColor = 'red'
sentimentArrow = 'bottom'
else:
sentimentColor = 'green'
sentimentArrow = 'up'
nse = Nse()
q = nse.get_quote('ioc')
q1 = q['closePrice']
ioc = pd.read_csv('E:\College\Final Year Project\Dataset\IOC.NS.csv')
contents = ['Date', 'Open', 'High', 'Low', 'Close', 'Adj Close', 'Volume']
ioc.columns = contents
ioc.drop('Adj Close', axis=1, inplace=True)
tempOpen = ioc['Open']
openList = tempOpen.tolist()
tempClose = ioc['Close']
closeList = tempClose.tolist()
tempDate = ioc['Date']
dateList0 = tempDate.tolist()
dateList = dateList0.reverse()
trendValue = float(predicted_value) - q1
if (trendValue > 0):
color = 'green'
arrow = 'top'
if (trendValue < 0):
color = 'red'
arrow = 'bottom'
try:
graph = pygal.Line()
graph.title = 'IOC Timeline'
graph.x_labels = dateList0
graph.add('Open', openList)
graph.add('Close', closeList)
graph_data = graph.render_data_uri()
return render_template('ioc.html',
q=q1,
graph_data=graph_data,
predicted_value=predicted_value,
trend=trend,
color=color,
arrow=arrow,
sentimentColor=sentimentColor,
sentimentArrow=sentimentArrow)
except Exception, e:
return (str(e))
def index(request,code=None):
# return HttpResponse('Hello from Python!')
nse = Nse()
if nse.is_valid_code(code):
print code
q = nse.get_quote(str(code))
return JsonResponse(q)
return HttpResponse("not valide")
def sendemail(request):
# check for breakeven price
import smtplib
stock_list = nse_m_stocklist.objects.filter(stock_type='WL')
for stock in stock_list:
stockprice = 0
nse = Nse()
try:
q = nse.get_quote(stock.stock_code)
for price in q.items():
if price[0] == 'lastPrice':
stockprice = price[1]
break
except:
stockprice = 0
stock.currprice = stockprice
# stock.save()
if (float(stock.currprice) < float(stock.notval1)) and (float(
stock.currprice) > float(
stock.notval3)): # Buy more notification
SUBJECT = 'Buy More Notification' + stock.stock_code + '\n'
BODY = stock.stock_code + ' stock has reached buy more notification \n' + stock.notval1
if float(stock.currprice) > float(stock.notval2): # Sell notification
SUBJECT = 'Sell Notification' + stock.stock_code + '\n'
BODY = stock.stock_code + ' stock has reached Sell notification Levels \n' + stock.notval2
if float(stock.currprice) < float(
stock.notval3): # Stop Loss notification
SUBJECT = 'Stop Loss Notification' + stock.stock_code + '\n'
BODY = stock.stock_code + ' stock has reached Stop Loss notification Levels \n' + stock.notval3
fromaddr = '*****@*****.**'
recipients = [
'*****@*****.**', '*****@*****.**'
]
#toaddrs = ", ".join(recipients)
toaddrs = '*****@*****.**'
#msg = 'Why,Oh why!'
# Prepare actual message
#msg = """From: %s\nTo: %s\nSubject: %s\n\n%s
#""" % (fromaddr, ", ".join(toaddrs), SUBJECT, BODY)
msg = 'Subject: {}\n\n{}'.format(SUBJECT, BODY)
username = '******'
password = '******'
server = smtplib.SMTP('smtp.gmail.com:587')
server.ehlo()
server.starttls()
server.login(username, password)
server.sendmail(
fromaddr,
toaddrs,
msg,
)
server.quit()
return redirect('My_Stock_Summary')
def summarysheet(request):
if request.user.is_authenticated():
investedtot = 0
currentval = 0
pltot = 0
returnper = 0
stock_list = nse_m_summarysheet.objects.filter(stock_type='SH')
for stock in stock_list:
stockprice = 0
nse = Nse()
try:
q = nse.get_quote(stock.stock_code)
for price in q.items():
if price[0] == 'lastPrice':
stockprice = price[1]
break
except:
stockprice = 0
stock.currprice = stockprice
stock.currvalue = round(
(float(stockprice) * float(stock.totbuyqty)), 1)
stock.buyvalue = round(
(float(stock.totbuyqty) * float(stock.avgbuyprice)), 1)
z = int(stock.currvalue) - int(stock.buyvalue)
stock.realpos = ''
stock.realpos = int(z)
investedtot = investedtot + int(stock.buyvalue)
currentval = currentval + int(stock.currvalue)
pltot = pltot + stock.realpos # (currentval - investedtot)
stock.save()
try:
returnper = int((pltot / investedtot) * 100)
except:
returnper = 0
table_data = nse_m_summarysheet.objects.filter(stock_type='SH')
table_data = table_data.order_by('-stock_code')
table = nse_t_summarysheet(table_data)
RequestConfig(request).configure(table)
# Summary table
summary_table = nse_t_summary([{
'invval': investedtot,
'curval': currentval,
'retval': pltot,
'retper': returnper
}])
RequestConfig(request).configure(summary_table)
context = {
'table': table,
'table_sum': summary_table,
}
return render(request, 'nse/summarysheet.html', context)
else:
return HttpResponseRedirect('/login')
def myfuc(s):
from nsetools import Nse
nse = Nse()
#list1=[]
#for x in file:
q = nse.get_quote(s)
k = (q['buyPrice1'])
#list1.append(k)
return (k)
def stock_price(symbol):
"""
This function returns the last
price of the given symbol.
None if the symbol is not valid.
"""
nse = Nse()
if nse.is_valid_code(symbol):
q = nse.get_quote(symbol)
return q.get('lastPrice', None)
else:
sym = symbolmatcher.findSymbol(symbol)
if sym is not None:
q = nse.get_quote(sym)
return q.get('lastPrice', None)
else:
logger.error("Unknown symbol " + symbol)
return None
def my_main():
filename = sys.argv[-1]
nse = Nse()
sym = 'INFY'
if (filename == 'getWeeklyMA.py'):
print('Hello Python')
print(sym +' : ' + getWMA(sym) + '\n')
print("------------------------------------------------------------------")
print(" Portfolio - Weekly Data ")
print("------------------------------------------------------------------")
print("%4s %15s %5s %8s %8s %8s %8s %8s %7s"%("No","Symbol", "trend", "20WMA", " RSI(14)", " CMP"" 52WeekHigh", " %UpPotential", "%RiskMargin", "Ratio"))
wma, rsi, cmp, trend = getWMAandRSI(sym, -2.0)
#print(wma);
q = nse.get_quote(sym)
h52 = q['high52']
upp = ((h52-cmp)/(cmp))*100.00
risk = ((cmp-wma)/cmp)*100.00
ratio = upp/risk
print("%4s %15s %5s %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f"%(1, sym, trend, wma, rsi, cmp, h52, upp, risk, ratio))
else:
# Using readlines()
file1 = open(filename, 'r')
Lines = file1.readlines()
print("------------------------------------------------------------------")
print(" Portfolio - Weekly Data ")
print("------------------------------------------------------------------")
print("%4s %15s %5s %8s %8s %8s %8s %8s %7s"%("No","Symbol", "trend", "20WMA", " RSI(14)", " CMP"" 52WeekHigh", " %UpPotential", "%RiskMargin", "Ratio"))
cnt = 1
for line in Lines:
sym = line.strip()
#print("{} {} {}".format(cnt, sym, getWMA(sym)))
#print("%4s %15s %8s %8s"%(cnt, sym, getWMA(sym), getRSI(sym)))
wma, rsi, cmp, trend = getWMAandRSI(sym, -2.0)
#print(wma);
q = nse.get_quote(sym)
h52 = q['high52']
upp = ((h52-cmp)/(cmp))*100.00
risk = ((cmp-wma)/cmp)*100.00
ratio = upp/risk
print("%4s %15s %5s %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f"%(cnt, sym, trend, wma, rsi, cmp, h52, upp, risk, ratio))
cnt += 1
def get_stock_details():
nse = Nse()
print(
"{:<10} | {:<7} | {:<7} | {:<7} | {:<7} | {:<7} | {:<7} | {:<6} | {:<7} | {:<10} | {:<2}"
.format("Symbol", "Avg Price", "LTP", "Open", "High", "Low", "Close",
"Change", "Prev Close", "Qty Traded", "Market Type"))
for stock in settings.STOCKS:
stock_data = nse.get_quote(stock)
stock_data = extract_stock_data(stock_data)
print_stock_data(stock_data)
class Real_Time_Stock_Data(APIView):
def __init__(self):
self.nse = Nse()
def get(self, request):
stock_list = []
dataframe = pd.read_csv(os.path.join(settings.BASE_DIR, 'stock_list.csv'))
# head = dataframe.head()
for index, row in dataframe.iterrows():
stock_dict = {}
stock_dict['id'] = index + 1
stock_dict['name'] = row['Company Name']
stock_dict['index_nm'] = row['Symbol']
stock_dict['currency'] = "INR"
stock_dict["market"] = "NSE"
stock_value = self.nse.get_quote(row['Symbol'])
# stock_value = self.nse.get_quote(row)
stock_dict['value'] = str(stock_value['lastPrice'])
if isinstance(stock_value['pChange'], str) and stock_value['pChange'].find('-') != -1:
stock_dict['state'] = '-'
stock_dict['state_value'] = str(stock_value['change'])
stock_dict['percent_state'] = str(stock_value['pChange']) + "%"
else:
stock_dict['state'] = "+"
stock_dict['state_value'] = str(stock_value['change'])
stock_dict['percent_state'] = str(stock_value['pChange']) + "%"
stock_list.append(stock_dict)
return JsonResponse({"data": stock_list})
def post(self, request):
lastprice_dict = {}
symbols = dict(request.data)['symbols']
for index, symbol in enumerate(symbols):
last_price = self.nse.get_quote(symbol)['lastPrice']
lastprice_dict[symbol] = last_price
return JsonResponse(lastprice_dict)
def my_main():
option = sys.argv[-1]
nse = Nse()
[dictLargeCap, dictMidCap, dictSmallCap] = getAllCapStocks(False)
d = dictLargeCap
#d = { 'INFY' : 123}
if (option == '-m'):
d = dictMidCap
if (option == '-s'):
d = dictSmallCap
cnt = 1
print(
"--------------------------------------------------------------------------------------"
)
print(
" Screener Portfolio - Weekly Data "
)
print(
"--------------------------------------------------------------------------------------"
)
print("%4s %15s %5s %8s %8s %8s %8s %8s %8s" %
("No", "Symbol", "Trnd", "20WMA", " RSI(14)", "CMP",
" 52WeekHigh", " %UpPotential", "%RiskMargin"))
df = pd.DataFrame(columns=("No", "Symbol", "Trend", "20WMA", "RSI(14)",
"CMP", "52WeekHigh", "%UpPotential",
"%RiskMargin"))
for sym in d:
print(sym)
#if sym == 'ADANIGAS':
# continue
wma, rsi, cmp, trnd = getWMAandRSI(sym)
print(wma, rsi, cmp, trnd) # = 0.0, 0.0, 0.0, 'UP'
#wma, rsi, cmp, trnd = 0.0, 0.0, 0.0, 'UP'
if (rsi > 59.9 and rsi < 65):
#if(rsi > -1.0 ):
q = nse.get_quote(sym)
h52 = q['high52']
upp = ((h52 - cmp) / (cmp)) * 100.00
risk = ((cmp - wma) / cmp) * 100.00
print("%4s %15s %5s %10.2f %10.2f %10.2f %10.2f %10.2f %10.2f" %
(cnt, sym, trnd, wma, rsi, cmp, h52, upp, risk))
i = cnt - 1
df.loc[cnt] = [cnt, sym, trnd, wma, rsi, cmp, h52, upp, risk]
cnt += 1
print(
"--------------------------------------------------------------------------------------"
)
df = df.sort_values(by='RSI(14)', ascending=False, na_position='first')
pprint(df)
class NseInitializer:
def __init__(self):
self.nse = Nse()
def get_stock_codes(self):
all_stock_codes = self.nse.get_stock_codes()
return all_stock_codes
def get_quote(self,symbol):
quote = self.nse.get_quote(symbol)
return quote
def fetch_stocks(cls):
nse = Nse()
print(nse)
json_data = StocksData.fetch_ticker_list()
count = 0
for (attribute, value) in json_data.items():
if count == 0:
count += 1
continue
print(attribute, value)
q = nse.get_quote(attribute)
AwsMessage.upload_msg(q, AwsMessage.stock_address)
count += 1
def plstatement(request):
investedtot = 0
currentval = 0
pltot = 0
returnper = 0
stock_list = nse_m_stocklist.objects.filter(stock_type='PL')
for stock in stock_list:
stockprice = 0
nse = Nse()
try:
q = nse.get_quote(stock.stock_code)
for price in q.items():
if price[0] == 'lastPrice':
stockprice = price[1]
break
except:
stockprice = 0
stock.buyvalue = round((float(stock.buyqty) * float(stock.buyprice)),
1)
z = int(float(stock.sellvalue)) - int(stock.buyvalue)
stock.realpos = ''
stock.realpos = int(z)
investedtot = investedtot + int(stock.buyvalue)
currentval = currentval + int(float(stock.sellvalue))
pltot = pltot + (currentval - investedtot)
stock.save()
try:
returnper = int((pltot / investedtot) * 100)
except:
returnper = 0
table_data = nse_m_stocklist.objects.filter(stock_type='PL')
table = nse_t_pllist(table_data)
RequestConfig(request).configure(table)
# Summary table
summary_table = nse_t_summary([{
'invval': investedtot,
'curval': currentval,
'retval': pltot,
'retper': returnper
}])
RequestConfig(request).configure(summary_table)
context = {
'table': table,
'table_sum': summary_table,
}
return render(request, 'nse/plstatement.html', context)
class NSEDataFetch(Nse):
def __init__(self):
self.nse = Nse()
self.equity_stock_watch_all = "https://www.nse-india.com/live_market/dynaContent/live_watch/stock_watch/niftyStockWatch.json"
def get_active_monthly(self):
pprint(self.nse.get_active_monthly())
def get_quote(self, symbol):
pprint(self.nse.get_quote(symbol))
def download_bhavcopy(self, date_string):
arr = []
response = self.nse.download_bhavcopy(date_string)
s = io.StringIO(response.decode('utf-8'))
headers = s.readlines(1)[0].split(',')
filename = "BavCopy{}.xlsx".format(datetime.now())
for line in s:
fields = map(lambda s: s.strip(), line.split(','))
columns = list(fields)
#bad coding here, need to remove the hardcoded values,
#need to automate this hardcoded value
arr.append({
headers[0]: columns[0],
headers[1]: columns[1],
headers[2]: columns[2],
headers[3]: columns[3],
headers[4]: columns[4],
headers[5]: columns[5],
headers[6]: columns[6],
headers[7]: columns[7],
headers[8]: columns[8],
headers[9]: columns[9],
headers[10]: columns[10],
headers[11]: columns[11],
headers[12]: columns[12],
headers[13]: columns[13]
})
pd.read_json(json.dumps(arr)).to_excel(filename)
def get_equity_stock_watch_live(self):
response = self.nse._get_json_response_from_url(
self.equity_stock_watch_all, True)
filename = "EquityMatketWatch{}.xls".format(datetime.now())
df = pd.read_json(response)
df.to_excel(filename)
def get_stock_codes(self):
self.nse.get_stock_codes()
def GET(self, nseids):
print(nseids)
ids = nseids.split(',')
nse = Nse()
pricelist = []
for nseid in ids:
details = nse.get_quote(nseid)
name = details.get('companyName')
price = details.get('lastPrice')
pricelist.append({
'nseid': nseid,
'Company Name': name,
'Price': price
})
return json.dumps(pricelist)
def run(self):
try:
nse = Nse()
try:
rate = nse.get_quote(str(self.code))
rate = rate['lastPrice']
except Exception, err:
print err
return
share = stock.objects.get(code=self.code)
if share.price != rate:
share.update = share.update + 1
share.price = rate
if rate > share.max_price_of_day:
share.max_price_of_day = rate
share.save()
print "sucess"
def run(self): try : nse = Nse() try : rate = nse.get_quote(str(self.code)) rate = rate['lastPrice'] except Exception,err : print err return share = stock.objects.get(code=self.code) if share.price != rate: share.update = share.update +1 share.price = rate if rate > share.max_price_of_day: share.max_price_of_day = rate share.save() print "sucess"
def price(code):
#print("got request")
#print(code)
nse = Nse()
stock_code = nse.get_stock_codes()
#stocks = ['20MICRONS', '3IINFOTECH','3MINDIA','8KMILES','A2ZINFRA','AARTIDRUGS','AARTIIND']
dic = {}
#for code in stocks:
out = nse.get_quote(code)
dic[code] = out['lastPrice']
print(dic)
with open("sample.json", "w") as outfile:
json.dump(dic, outfile)
with open('sample.json') as data_file:
data = json.load(data_file)
#print(data)
return data
def classes(request):
nse = Nse()
a = [
'ABB', 'DMART', 'BHEL', 'TITAN', 'TATAPOWER', 'INDIGO', 'IDEA', 'MRF',
'PNB', 'GODREJCP', 'LICHSGFIN', 'JSWSTEEL'
]
price = []
hprice = []
lprice = []
oprice = []
for i in a:
q = nse.get_quote(i)
price.append(q['averagePrice'])
hprice.append(q['dayHigh'])
lprice.append(q['dayLow'])
oprice.append(q['closePrice'])
loop = zip(a, price, hprice, lprice, oprice)
return render(request, 'classes.html', {'loop': loop})
class Parser():
nse = None
log_infix = 'Parser::'
default_query_list = [
'symbol', 'companyName', 'dayHigh', 'basePrice', 'dayLow',
'averagePrice', 'high52', 'low52'
]
def __init__(self):
self.nse = Nse()
self.log_infix + '__init__ '
logging.info('%s %s', (self.log_infix, self.nse))
def quote_by_stock_name(self, name, query_list=[]):
self.log_infix + 'quote_by_stock_name '
if (not name):
message = 'Name should be present'
logging.error(self.log_infix + message)
raise NameError(message)
if (not self.nse):
message = 'NSE Object Failure'
logging.error(self.log_infix + message)
raise ValueError(message)
print(f'nse value is {self.nse} and name is {name}')
query = self.nse.get_quote(name)
if (len(query_list) > 0):
queries = query_list
else:
queries = self.default_query_list
nse_obj = nse_object(query).retrieve_info(queries)
return nse_obj
def get_top_gainers(self):
self.log_infix + 'get_top_gainers '
if (not self.nse):
message = 'NSE Object Failure'
logging.error(self.log_infix + message)
raise ValueError(message)
query = self.nse.get_top_gainers()
nse_obj = nse_object(query).retrieve_info([])
return nse_obj
#logging.critical('This is a critical message')
if argnum != 2:
logging.info('More than one argument to script. Currently not supported')
print('');
exit();
logging.info('Attempting to fetch quotes for ' + scrip + '...');
from nsetools import Nse
nse = Nse()
if nse.is_valid_code(scrip):
logging.info('Scrip name is valid')
#Add Success attrib in JSON
q=nse.get_quote(scrip, as_json=True)
#q = '{ }';
quotedata = json.loads(q)
quotedata['Success'] = 1;
#Add timestamp:
#quote_time = datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S+0000");
T_UTC = datetime.utcnow()
T_in = T_UTC + timedelta(hours=5, minutes=30)
quote_time = T_in.strftime("%s");
quotedata['timestamp'] = quote_time;
q=json.dumps(quotedata);
print(q)
else:
logging.info('Invalid scrip name. Check https://www.nseindia.com to get correct scrip name.')
#Create JSON with fail attrib
class TestCoreAPIs(unittest.TestCase):
def setUp(self):
self.nse = Nse()
def test_string_representation(self):
self.assertEqual(str(self.nse), "Driver Class for National Stock Exchange (NSE)")
def test_instantiate_abs_class(self):
class Exchange(AbstractBaseExchange):
pass
with self.assertRaises(TypeError):
exc = Exchange()
def test_nse_headers(self):
ret = self.nse.nse_headers()
self.assertIsInstance(ret, dict)
def test_nse_opener(self):
""" should not raise any exception """
opener = self.nse.nse_opener()
def test_build_url_for_quote(self):
test_code = "infy"
url = self.nse.build_url_for_quote(test_code)
# 'test_code' should be present in the url
self.assertIsNotNone(re.search(test_code, url))
def test_negative_build_url_for_quote(self):
negative_codes = [1, None]
with self.assertRaises(Exception):
for test_code in negative_codes:
url = self.nse.build_url_for_quote(test_code)
def test_response_cleaner(self):
test_dict = {
"a": "10",
"b": "10.0",
"c": "1,000.10",
"d": "vsjha18",
"e": 10,
"f": 10.0,
"g": 1000.10,
"h": True,
"i": None,
"j": u"10",
"k": u"10.0",
"l": u"1,000.10",
}
expected_dict = {
"a": 10,
"b": 10.0,
"c": 1000.10,
"d": "vsjha18",
"e": 10,
"f": 10.0,
"g": 1000.10,
"h": True,
"i": None,
"j": 10,
"k": 10.0,
"l": 1000.10,
}
ret_dict = self.nse.clean_server_response(test_dict)
self.assertDictEqual(ret_dict, expected_dict)
def test_get_stock_codes(self):
sc = self.nse.get_stock_codes()
self.assertIsNotNone(sc)
self.assertIsInstance(sc, dict)
# test the json format return
sc_json = self.nse.get_stock_codes(as_json=True)
self.assertIsInstance(sc_json, str)
# reconstruct the dict from json and compare
six.assertCountEqual(self, sc, json.loads(sc_json))
# TODO: use mock and create one test where response contains a blank line
# TODO: use mock and create one test where response doesnt contain a csv
# TODO: use mock and create one test where return is null
# TODO: test the cache feature
def test_negative_get_quote(self):
wrong_code = "inf"
self.assertIsNone(self.nse.get_quote(wrong_code))
def test_get_quote(self):
code = "infy"
resp = self.nse.get_quote(code)
self.assertIsInstance(resp, dict)
# test json response
json_resp = self.nse.get_quote(code, as_json=True)
self.assertIsInstance(json_resp, str)
# reconstruct the original dict from json
# this test may raise false alarms in case the
# the price changed in that very moment.
self.assertDictEqual(resp, json.loads(json_resp))
def test_is_valid_code(self):
code = "infy"
self.assertTrue(self.nse.is_valid_code(code))
def test_negative_is_valid_code(self):
wrong_code = "in"
self.assertFalse(self.nse.is_valid_code(wrong_code))
def test_get_top_gainers(self):
res = self.nse.get_top_gainers()
self.assertIsInstance(res, list)
# test json response
res = self.nse.get_top_gainers(as_json=True)
self.assertIsInstance(res, str)
def test_get_top_losers(self):
res = self.nse.get_top_losers()
self.assertIsInstance(res, list)
def test_render_response(self):
d = {"fname": "vivek", "lname": "jha"}
resp_dict = self.nse.render_response(d)
resp_json = self.nse.render_response(d, as_json=True)
# in case of dict, response should be a python dict
self.assertIsInstance(resp_dict, dict)
# in case of json, response should be a json string
self.assertIsInstance(resp_json, str)
# and on reconstruction it should become same as original dict
self.assertDictEqual(d, json.loads(resp_json))
def test_advances_declines(self):
resp = self.nse.get_advances_declines()
# it should be a list of dictionaries
self.assertIsInstance(resp, list)
# get the json version
resp_json = self.nse.get_advances_declines(as_json=True)
self.assertIsInstance(resp_json, str)
# load the json response and it should have same number of
# elements as in case of first response
self.assertEqual(len(resp), len(json.loads(resp_json)))
def test_is_valid_index(self):
code = "CNX NIFTY"
self.assertTrue(self.nse.is_valid_index(code))
# test with invalid string
code = "some junk stuff"
self.assertFalse(self.nse.is_valid_index(code))
# test with lower case
code = "cnx nifty"
self.assertTrue(self.nse.is_valid_index(code))
def test_get_index_quote(self):
code = "CNX NIFTY"
self.assertIsInstance(self.nse.get_index_quote(code), dict)
# with json response
self.assertIsInstance(self.nse.get_index_quote(code, as_json=True), str)
# with wrong code
code = "wrong code"
self.assertIsNone(self.nse.get_index_quote(code))
# with lower case code
code = "cnx nifty"
self.assertIsInstance(self.nse.get_index_quote(code), dict)
def test_get_index_list(self):
index_list = self.nse.get_index_list()
index_list_json = self.nse.get_index_list(as_json=True)
self.assertIsInstance(index_list, list)
# test json response type
self.assertIsInstance(index_list_json, str)
# reconstruct list from json and match
self.assertListEqual(index_list, json.loads(index_list_json))
def test_jsadptor(self):
buffer = "abc:true, def:false, ghi:NaN, jkl:none"
expected_buffer = 'abc:True, def:False, ghi:"NaN", jkl:None'
ret = js_adaptor(buffer)
self.assertEqual(ret, expected_buffer)
def test_byte_adaptor(self):
if six.PY2:
from StringIO import StringIO
buffer = "nsetools"
fbuffer = StringIO(buffer)
else:
from io import BytesIO
buffer = b"nsetools"
fbuffer = BytesIO(buffer)
ret_file_buffer = byte_adaptor(fbuffer)
self.assertIsInstance(ret_file_buffer, six.StringIO)
from nsetools import Nse from pprint import pprint nse = Nse() all_stock_codes = nse.get_stock_codes() pprint(all_stock_codes) for x in all_stock_codes: pprint(nse.get_quote(x))
class TestCoreAPIs(unittest.TestCase):
def setUp(self):
self.nse = Nse()
def test_string_representation(self):
self.assertEqual(str(self.nse) ,
"Driver Class for National Stock Exchange (NSE)")
def test_instantiate_abs_class(self):
class Exchange(AbstractBaseExchange): pass
with self.assertRaises(TypeError):
exc = Exchange()
def test_nse_headers(self):
ret = self.nse.nse_headers()
self.assertIsInstance(ret, dict)
def test_nse_opener(self):
''' should not raise any exception '''
opener = self.nse.nse_opener()
def test_build_url_for_quote(self):
test_code = 'infy'
url = self.nse.build_url_for_quote(test_code)
# 'test_code' should be present in the url
self.assertIsNotNone(re.search(test_code, url))
def test_negative_build_url_for_quote(self):
negative_codes = [1, None]
with self.assertRaises(Exception):
for test_code in negative_codes:
url = self.nse.build_url_for_quote(test_code)
def test_response_cleaner(self):
test_dict = {
'a': '10',
'b': '10.0',
'c': '1,000.10',
'd': 'vsjha18',
'e': 10,
'f': 10.0,
'g': 1000.10,
'h': True,
'i': None,
'j': u'10',
'k': u'10.0',
'l': u'1,000.10'
}
expected_dict = {
'a': 10,
'b': 10.0,
'c': 1000.10,
'd': 'vsjha18',
'e': 10,
'f': 10.0,
'g': 1000.10,
'h': True,
'i': None,
'j': 10,
'k': 10.0,
'l': 1000.10
}
ret_dict = self.nse.clean_server_response(test_dict)
self.assertDictEqual(ret_dict, expected_dict)
def test_get_stock_codes(self):
sc = self.nse.get_stock_codes()
self.assertIsNotNone(sc)
self.assertIsInstance(sc, dict)
# test the json format return
sc_json = self.nse.get_stock_codes(as_json=True)
self.assertIsInstance(sc_json, str)
# reconstruct the dict from json and compare
self.assertItemsEqual(sc, json.loads(sc_json))
# TODO: use mock and create one test where response contains a blank line
# TODO: use mock and create one test where response doesnt contain a csv
# TODO: use mock and create one test where return is null
# TODO: test the cache feature
def test_negative_get_quote(self):
wrong_code = 'inf'
self.assertIsNone(self.nse.get_quote(wrong_code))
def test_get_quote(self):
code = 'infy'
resp = self.nse.get_quote(code)
self.assertIsInstance(resp, dict)
# test json response
json_resp = self.nse.get_quote(code, as_json=True)
self.assertIsInstance(json_resp, str)
# reconstruct the original dict from json
# this test may raise false alarms in case the
# the price changed in that very moment.
self.assertDictEqual(resp, json.loads(json_resp))
def test_is_valid_code(self):
code = 'infy'
self.assertTrue(self.nse.is_valid_code(code))
def test_negative_is_valid_code(self):
wrong_code = 'in'
self.assertFalse(self.nse.is_valid_code(wrong_code))
def test_get_top_gainers(self):
res = self.nse.get_top_gainers()
self.assertIsInstance(res, list)
# test json response
res = self.nse.get_top_gainers(as_json=True)
self.assertIsInstance(res, str)
def test_get_top_losers(self):
res = self.nse.get_top_losers()
self.assertIsInstance(res, list)
def test_render_response(self):
d = {'fname':'vivek', 'lname':'jha'}
resp_dict = self.nse.render_response(d)
resp_json = self.nse.render_response(d, as_json=True)
# in case of dict, response should be a python dict
self.assertIsInstance(resp_dict, dict)
# in case of json, response should be a json string
self.assertIsInstance(resp_json, str)
# and on reconstruction it should become same as original dict
self.assertDictEqual(d, json.loads(resp_json))
def test_advances_declines(self):
resp = self.nse.get_advances_declines()
# it should be a list of dictionaries
self.assertIsInstance(resp, list)
# get the json version
resp_json = self.nse.get_advances_declines(as_json=True)
self.assertIsInstance(resp_json, str)
# load the json response and it should have same number of
# elements as in case of first response
self.assertEqual(len(resp), len(json.loads(resp_json)))
def test_is_valid_index(self):
code = 'CNX NIFTY'
self.assertTrue(self.nse.is_valid_index(code))
# test with invalid string
code = 'some junk stuff'
self.assertFalse(self.nse.is_valid_index(code))
# test with lower case
code = 'cnx nifty'
self.assertTrue(self.nse.is_valid_index(code))
def test_get_index_quote(self):
code = 'CNX NIFTY'
self.assertIsInstance(self.nse.get_index_quote(code), dict)
# with json response
self.assertIsInstance(self.nse.get_index_quote(code, as_json=True),
str)
# with wrong code
code = 'wrong code'
self.assertIsNone(self.nse.get_index_quote(code))
# with lower case code
code = 'cnx nifty'
self.assertIsInstance(self.nse.get_index_quote(code), dict)
def test_get_index_list(self):
index_list = self.nse.get_index_list()
index_list_json = self.nse.get_index_list(as_json=True)
self.assertIsInstance(index_list, list)
# test json response type
self.assertIsInstance(index_list_json, str)
# reconstruct list from json and match
self.assertListEqual(index_list, json.loads(index_list_json))
class TestCoreAPIs(unittest.TestCase):
def setUp(self):
self.nse = Nse()
def test_string_representation(self):
self.assertEqual(str(self.nse), "Driver Class for National Stock Exchange (NSE)")
def test_instantiate_abs_class(self):
class Exchange(AbstractBaseExchange):
pass
with self.assertRaises(TypeError):
exc = Exchange()
def test_nse_headers(self):
ret = self.nse.nse_headers()
self.assertIsInstance(ret, dict)
def test_nse_opener(self):
''' should not raise any exception '''
opener = self.nse.nse_opener()
def test_build_url_for_quote(self):
test_code = 'infy'
url = self.nse.build_url_for_quote(test_code)
# 'test_code' should be present in the url
self.assertIsNotNone(re.search(test_code, url))
def test_negative_build_url_for_quote(self):
negative_codes = [1, None]
with self.assertRaises(Exception):
for test_code in negative_codes:
url = self.nse.build_url_for_quote(test_code)
def test_response_cleaner(self):
test_dict = {
'a': '10',
'b': '10.0',
'c': '1,000.10',
'd': 'vsjha18',
'e': 10,
'f': 10.0,
'g': 1000.10,
'h': True,
'i': None,
'j': u'10',
'k': u'10.0',
'l': u'1,000.10'
}
expected_dict = {
'a': 10,
'b': 10.0,
'c': 1000.10,
'd': 'vsjha18',
'e': 10,
'f': 10.0,
'g': 1000.10,
'h': True,
'i': None,
'j': 10,
'k': 10.0,
'l': 1000.10
}
ret_dict = self.nse.clean_server_response(test_dict)
self.assertDictEqual(ret_dict, expected_dict)
def test_get_stock_codes(self):
sc = self.nse.get_stock_codes()
self.assertIsNotNone(sc)
self.assertIsInstance(sc, dict)
# test the json format return
sc_json = self.nse.get_stock_codes(as_json=True)
self.assertIsInstance(sc_json, str)
# reconstruct the dict from json and compare
six.assertCountEqual(self, sc, json.loads(sc_json))
# TODO: use mock and create one test where response contains a blank line
# TODO: use mock and create one test where response doesnt contain a csv
# TODO: use mock and create one test where return is null
# TODO: test the cache feature
def test_negative_get_quote(self):
wrong_code = 'inf'
self.assertIsNone(self.nse.get_quote(wrong_code))
def test_get_quote(self):
code = 'infy'
resp = self.nse.get_quote(code)
self.assertIsInstance(resp, dict)
# test json response
json_resp = self.nse.get_quote(code, as_json=True)
self.assertIsInstance(json_resp, str)
# reconstruct the original dict from json
# this test may raise false alarms in case the
# the price changed in that very moment.
self.assertDictEqual(resp, json.loads(json_resp))
def test_is_valid_code(self):
code = 'infy'
self.assertTrue(self.nse.is_valid_code(code))
def test_negative_is_valid_code(self):
wrong_code = 'in'
self.assertFalse(self.nse.is_valid_code(wrong_code))
def test_get_top_gainers(self):
res = self.nse.get_top_gainers()
self.assertIsInstance(res, list)
# test json response
res = self.nse.get_top_gainers(as_json=True)
self.assertIsInstance(res, str)
def test_get_top_losers(self):
res = self.nse.get_top_losers()
self.assertIsInstance(res, list)
def test_render_response(self):
d = {'fname':'vivek', 'lname':'jha'}
resp_dict = self.nse.render_response(d)
resp_json = self.nse.render_response(d, as_json=True)
# in case of dict, response should be a python dict
self.assertIsInstance(resp_dict, dict)
# in case of json, response should be a json string
self.assertIsInstance(resp_json, str)
# and on reconstruction it should become same as original dict
self.assertDictEqual(d, json.loads(resp_json))
def test_advances_declines(self):
resp = self.nse.get_advances_declines()
# it should be a list of dictionaries
self.assertIsInstance(resp, list)
# get the json version
resp_json = self.nse.get_advances_declines(as_json=True)
self.assertIsInstance(resp_json, str)
# load the json response and it should have same number of
# elements as in case of first response
self.assertEqual(len(resp), len(json.loads(resp_json)))
def test_is_valid_index(self):
code = 'NIFTY BANK'
self.assertTrue(self.nse.is_valid_index(code))
# test with invalid string
code = 'some junk stuff'
self.assertFalse(self.nse.is_valid_index(code))
# test with lower case
code = 'nifty bank'
self.assertTrue(self.nse.is_valid_index(code))
def test_get_index_quote(self):
code = 'NIFTY BANK'
self.assertIsInstance(self.nse.get_index_quote(code), dict)
# with json response
self.assertIsInstance(self.nse.get_index_quote(code, as_json=True),
str)
# with wrong code
code = 'wrong code'
self.assertIsNone(self.nse.get_index_quote(code))
# with lower case code
code = 'nifty bank'
self.assertIsInstance(self.nse.get_index_quote(code), dict)
def test_get_index_list(self):
index_list = self.nse.get_index_list()
index_list_json = self.nse.get_index_list(as_json=True)
self.assertIsInstance(index_list, list)
# test json response type
self.assertIsInstance(index_list_json, str)
# reconstruct list from json and match
self.assertListEqual(index_list, json.loads(index_list_json))
def test_jsadptor(self):
buffer = 'abc:true, def:false, ghi:NaN, jkl:none'
expected_buffer = 'abc:True, def:False, ghi:"NaN", jkl:None'
ret = js_adaptor(buffer)
self.assertEqual(ret, expected_buffer)
def test_byte_adaptor(self):
if six.PY2:
from StringIO import StringIO
buffer = 'nsetools'
fbuffer = StringIO(buffer)
else:
from io import BytesIO
buffer = b'nsetools'
fbuffer = BytesIO(buffer)
ret_file_buffer = byte_adaptor(fbuffer)
self.assertIsInstance(ret_file_buffer, six.StringIO)
def test_nse_lot_sizes(self):
data = self.nse.get_fno_lot_sizes()
self.assertIsInstance(data, dict)
def test_6th_Dec_1994(self):
data = self.nse.download_bhavcopy('1994-12-06')
self.assertIsInstance(self, data, bytes)
def test_top_fno_gainers_losers(self):
fno_gainer = self.nse.get_top_fno_gainers()
self.assertIsInstance(fno_gainer, list)
fno_gainer_json = self.nse.get_top_fno_gainers(as_json=True)
self.assertIsInstance(fno_gainer_json, str)
fno_loser = self.nse.get_top_fno_losers()
self.assertIsInstance(fno_loser, list)
fno_loser_json = self.nse.get_top_fno_losers(as_json=True)
self.assertIsInstance(fno_loser_json, str)
def test_statistics(self):
active = self.nse.get_active_monthly()
self.assertIsInstance(active, list)
active_json = self.nse.get_active_monthly(as_json=True)
self.assertIsInstance(active_json, str)
yr_high = self.nse.get_year_high()
self.assertIsInstance(yr_high, list)
yr_high_json = self.nse.get_year_high(as_json=True)
self.assertIsInstance(yr_high_json, str)
yr_low = self.nse.get_year_low()
self.assertIsInstance(yr_low, list)
yr_low_json = self.nse.get_year_low(as_json=True)
self.assertIsInstance(yr_low_json, str)
preopen = self.nse.get_preopen_nifty()
self.assertIsInstance(preopen, list)
preopen_json = self.nse.get_preopen_nifty(as_json=True)
self.assertIsInstance(preopen_json, str)
preopen_nb = self.nse.get_preopen_niftybank()
self.assertIsInstance(preopen_nb, list)
preopen_nb_json = self.nse.get_preopen_niftybank(as_json=True)
self.assertIsInstance(preopen_nb_json, str)
preopen_fno = self.nse.get_preopen_fno()
self.assertIsInstance(preopen_fno, list)
preopen_fno_json = self.nse.get_preopen_fno(as_json=True)
self.assertIsInstance(preopen_fno_json, str)
class UpdateData:
def __init__(self,index):
self.nse = Nse()
self.date=date.today()
self.index = index
self.stock_data = {}
self.stock_data = self.init_content()
if self.stock_data is None:
self.stock_data={}
self.update_index()
#pprint(self.stock_data)
def update_index(self):
count = 0
with open(self.index) as myfile:
for line in myfile:
if count is not 0:
line = line.split(',')
try:
self.update_content(line[2])
except:
continue
#self.update_hlc(line[2])
else :
count = 1
self.save_content()
# self.write_update('day')
def get_index():
return self.index
def update_content(self,stock):
try:
print stock
data = self.nse.get_quote(stock)
except:
raise ValueError
self.stock_data[stock] = data
def get_content(self,stock):
return self.stock_data.get(stock)
def read_dict_from_file(self,dir_name,name):
extension = 'txt'
index = NIFTYLIST[self.index]
filename = BASE_PATH+index+SEPERATOR+dir_name+SEPERATOR+name+'.'+extension
try:
if(os.path.isfile(filename)):
with open(filename) as myfile:
"+ 1 is done because of 1st line in file "
data = json.load(myfile)
return data
except:
raise ValueError
def write_dict_to_file(self,dir_name,data,mode,name = None):
if data is None:
return
extension = 'txt'
index = NIFTYLIST[self.index]
filename = BASE_PATH+index+SEPERATOR+dir_name+SEPERATOR+name+'.'+extension
directory = os.path.dirname(filename)
if not os.path.exists(directory):
os.makedirs(directory)
with open(filename, mode) as outfile:
json.dump(data, outfile)
def init_content(self):
#self.update_index()
name = 'Stocks Content'
dir_name= 'Daily'
return self.read_dict_from_file(dir_name,name)
def save_content(self):
name = 'Stocks Content'
dir_name= 'Daily'
self.write_dict_to_file(dir_name,self.stock_data,'w',name)
def update_val(self,data,stock):
change = False
high = self.stock_data[stock]['dayHigh']
low = self.stock_data[stock]['dayLow']
if data['High'] < high:
data['High'] = high
change = True
if data['Low'] > low:
data['Low'] = low
change = True
return {"Data": data, "Change":change}
def update_hlc(self,stock):
data = self.read_dict_from_file('HLC',stock)
change = False
for key in data:
val = self.update_val(data[key],stock)
if val['Change']:
data[key] = val['Data']
change = True
if change:
self.write_dict_to_file('HLC',data,'w',stock)
print "Updated ",stock
def read_update(self,period):
extension = 'txt'
filename = BASE_PATH+'update_'+period+'.'+extension
if(os.path.isfile(filename)):
with open(filename) as myfile:
head = list(islice(myfile, 1))
return head
else:
self.write_update(period)
return self.date
def write_update(self,period):
extension = 'txt'
filename = BASE_PATH+'update_'+period+'.'+extension
with open(filename, 'w') as outfile:
outfile.write(self.date.strftime('%d-%m-%Y'))
def update(self):
day_update = self.read_update('day')
month_update = self.read_update('month')
day_update = datetime.strptime(day_update[0],'%d-%m-%Y').date()
month_update = datetime.strptime(month_update[0],'%d-%m-%Y').date()
flagday = False
flagmonth =False
count = 0
for ind in NIFTYLIST:
self.index = ind
index = NIFTYLIST[ind]
if self.date.day - day_update.day > 0 or self.date.month - day_update.month > 0:
self.update_index()
flagday =True
if self.date.month - month_update.month > 0:
if self.check_month_change(month_update.month):
self.update_monthly()
shutil.rmtree(BASE_PATH+SEPERATOR+index+SEPERATOR+'HLC')
flagmonth =True
if flagday:
self.write_update('day')
if count ==1:
return True
if flagmonth:
self.write_update('month')
if count ==1:
return True
count = count + 1
return False
def check_month_change(self,udate):
data = StockData('INFY',self)
mydate = date.today()
#html = data.get_historical_data(mydate.strftime('%d-02-%Y'),mydate.strftime('%d-%m-%Y'),'m')
html = data.get_today_data()
line =html.split('\n')
line = line[1].split(',')
data_date = int(line[0].split('-')[1])
val = False
if data_date - udate > 0:
val= True
return val
def update_monthly(self):
count = 0
with open(self.index) as myfile:
for line in myfile:
if count is not 0:
line = line.split(',')
try:
stock = StockData(line[2],self)
stock.save_historical_data('1-1-1976',self.date.strftime('%d-%m-%Y'),'m')
except:
continue
#self.update_hlc(line[2])
else :
count = 1
#self.write_update('month')
def return_file_data(self):
filename = self.index
if(os.path.isfile(filename)):
with open(filename) as myfile:
"+ 1 is done because of 1st line in file "
head = list(islice(myfile,1,1000))
return head
def toCsv(stock, name, header=False):
ts = time.time()
timeStamp = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
transposedEntry = DataFrame(stock.values(), index=stock.keys(), columns=[timeStamp])
entry = transposedEntry.T
with open(name+".csv", 'a') as file:
if header:
entry.to_csv(file, header=True)
else:
entry.to_csv(file, header=False)
#################################################################################################
#Intialize Nse
nse = Nse()
stock_name = raw_input("Enter the stock nse id (eg: infy):")
past_stock_value = nse.get_quote(stock_name)
toCsv(past_stock_value, stock_name, True)
while True:
time.sleep(1) #assuming this delay will come from network :p
print "Getting stock value"
current_stock_value = nse.get_quote(stock_name)
print current_stock_value["sellPrice1"]
items_added, items_removed, items_modified, items_same = dict_compare(past_stock_value, current_stock_value)
if items_modified:
print "Stock value changed"
toCsv(current_stock_value, stock_name)
past_stock_value = copy.deepcopy(current_stock_value)
from pprint import pprint
import json
from nsetools import Nse
nse = Nse()
q = nse.get_quote('infy')
#pprint(q)
dict={}
dict['applicableMargin']=q['applicableMargin']
dict['averagePrice']=q['averagePrice']
dict['bcEndDate']=q['bcEndDate']
dict['bcStartDate']=q['bcStartDate']
print dict
# test
nse = Nse()
print nse
all_stock_codes = nse.get_stock_codes()
ticklist = all_stock_codes.keys()
ticklist = sorted(ticklist)
while True:
sata = pd.DataFrame()
for ticker in ticklist:
ptime = time.ctime()
try:
q = nse.get_quote(ticker)
qdf = pd.DataFrame(q.items(), columns=["Item", "Value"])
qdf["symbol"] = ticker
qdf["timestamp"] = ptime
# qdf = qdf.sort(['Item'])
sata = pd.concat([sata, qdf], axis=0, ignore_index=True)
except:
continue
sata.to_csv("nseOB11Nov2015.csv", index=False, mode="a")
data.sort(["symbol", "Item"], ascending=[False, True])
len(data.index) / 66
def get_quote(self, code, as_json=False):
