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 getstockList():
nse = Nse()
all_stock_code = nse.get_stock_codes(cached=True)
all_stock_codes = pd.DataFrame(list(all_stock_code.items()),
columns=["SYMBOL", "NAME OF COMPANY"])
all_stock_codes.drop(all_stock_codes.index[0], inplace=True)
Symbols = all_stock_codes['SYMBOL'].tolist()
isvalid = list(map(lambda x: nse.is_valid_code(x), Symbols))
all_stock_codes['isactve'] = isvalid
all_stock_codes['FUT'] = False
all_stock_codes['IDX'] = False
return all_stock_codes
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
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 process(input,entities):
output = {}
try:
nse = Nse()
symbol = " "
# symbol is the 'NSE symbol of the company'
s= input.split(' ')
for i in s:
if nse.is_valid_code(str(i)):
symbol = i
break
q = nse.get_quote(str(symbol))
# Getting Company name using variable symbol
company_name = q['companyName']
company_symbol = q['symbol']
# Getting open price of the day
open_price = q['open']
# Getting closing price of the day
close_price = q['closePrice']
# Getting average price of the day
stock_price = q['faceValue']
# Top gainers for the last trading session
# Top losers for the last trading session
output['input'] = "Stock_price"
msg = 'Company Name = '+company_name+" \n "+"Symbol = "+company_symbol+"\n "+"Open Price = "+str(open_price)+"\n"+"Close Price = "+str(close_price)+"\n"+"Stock Price = "+str(stock_price)
msg_1={'text':msg}
msg_1= add_quick_reply(msg_1, 'wipro stock', modules.generate_postback('stock_price'))
msg_1 = add_quick_reply(msg_1, 'Tell me a joke.', modules.generate_postback('joke'))
msg_1 = add_quick_reply(msg_1, 'roll a dice.', modules.generate_postback('dice'))
output['output']=msg_1
output['success']=True
except:
error_message = 'I couldn\'t understand the symbol '
error_message += '\nPlease ask something like tcs stock_price etc.'
output['error_msg'] = TextTemplate(error_message).get_message()
output['success'] = False
return output
def transform(row):
stockName = row[0]
quantity = float(row[1])
avgPrice = float(row[2])
currVal = quantity * avgPrice
nse = Nse()
if nse.is_valid_code(stockName):
nseStock = nse.get_quote(stockName)
#daychange = ((float(nseStock["change"]) / nseStock['basePrice']) * 100)
PL = (float(nseStock["lastPrice"]) - avgPrice) * quantity
PL_per = (float(nseStock["lastPrice"]) - avgPrice) / avgPrice * 100
exDate = nseStock["exDate"]
# if str(exDate=='None'):
# exDate=str("24-SEP-01")
return [
stockName,
int(quantity), avgPrice, nseStock["lastPrice"],
"%.2f" % currVal,
"%.2f" % PL,
"%.2f" % PL_per,
"%.2f" % float(nseStock["pChange"]), nseStock["dayHigh"],
nseStock["pricebandupper"], nseStock["pricebandlower"],
nseStock["deliveryQuantity"], nseStock["totalTradedVolume"],
nseStock["varMargin"], nseStock["high52"], nseStock["low52"],
stockName + nseStock["purpose"], exDate
]
else:
ltp = row[3]
currVal = row[4]
PL = row[5]
PL_per = row[6]
dayChg = row[7]
return [
stockName,
int(quantity), avgPrice, ltp, currVal, PL, PL_per, dayChg, "NA",
"NA", "NA", "NA", "NA", "NA", "NA", "NA", "NA",
str("24-SEP-01")
]
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_nse_headers(self):
ret = self.nse.nse_headers()
self.assertIsInstance(ret, dict)
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_get_peer_companies(self):
code = 'infy'
response = self.nse.get_peer_companies(code)
self.assertIsInstance(response, pd.DataFrame)
# This one was causing a weird error. as the offset was different
code = '63moons'
response = self.nse.get_peer_companies(code)
self.assertIsInstance(response, pd.DataFrame)
def test_market_status(self):
result = market_status()
self.assertIsInstance(result, bool)
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, pd.DataFrame)
if sc.empty:
self.fail()
# 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.assertEqual(self.nse.get_quote(wrong_code), None)
def test_get_quote(self):
resp = self.nse.get_quote('infy', '20Microns', 'abb')
self.assertEqual(len(resp), 3)
self.assertIsInstance(resp, pd.DataFrame)
# test json response
json_resp = self.nse.get_quote('infy',
'20Microns',
'abb',
as_json=True)
self.assertEqual(len(json_resp), 3)
self.assertIsInstance(json_resp[0], str)
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(self):
# as_json = False
# This test will remove the need to test the individual parts
result = self.nse.get_top('gainers', 'losers', 'volume', 'active',
'advances decline', 'index list', 'JUNK')
# Gainers/Losers/Volume/Advances Decline is supposed to return a list of dictionaries
# Index list is supposed to return a list of strings
# JUNK Should not return anything
temp = []
for item in result:
temp.append(item)
self.assertEqual(6, len(temp))
gainer, loser, volume, active, adv_decline, index_list = temp[0], temp[
1], temp[2], temp[3], temp[4], temp[5]
# Test these individually
self.assertIsInstance(gainer, pd.DataFrame)
self.assertIsInstance(loser, pd.DataFrame)
self.assertIsInstance(volume, pd.DataFrame)
self.assertIsInstance(adv_decline, pd.DataFrame)
self.assertIsInstance(index_list, list)
# Now as_json = True
result = self.nse.get_top('gainers',
'losers',
'volume',
'active',
'advances decline',
'index list',
as_json=True)
temp = []
for item in result:
temp.append(item)
self.assertEqual(6, len(temp))
gainer, loser, volume, active, adv_decline_json, index_list_json = temp[
0], temp[1], temp[2], temp[3], temp[4], temp[5]
self.assertIsInstance(gainer, str)
self.assertIsInstance(loser, str)
self.assertIsInstance(volume, str)
self.assertIsInstance(active, str)
self.assertIsInstance(adv_decline_json, str)
self.assertEqual(len(adv_decline), len(json.loads(adv_decline_json)))
self.assertIsInstance(index_list_json, str)
self.assertListEqual(index_list, json.loads(index_list_json))
def test_render_response(self):
d = {'fname': 'Arkoprabho', 'lname': 'Chakraborti'}
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_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_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):
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_save_file(self):
# Call the function, check if the file has been saved at the required location
dataframe = self.nse.get_stock_codes()
save_file(dataframe, 'csv', path=gettempdir(), name='StockCodes')
path = os.path.join(gettempdir(), 'StockCodes.csv')
if not os.path.exists(path):
self.fail()
save_file(dataframe, 'html', path=gettempdir(), name='StockCodes')
path = os.path.join(gettempdir(), 'StockCodes.html')
if not os.path.exists(path):
self.fail()
save_file(dataframe, 'json', path=gettempdir(), name='StockCodes')
path = os.path.join(gettempdir(), 'StockCodes.json')
if not os.path.exists(path):
self.fail()
save_file(dataframe, 'tex', path=gettempdir(), name='StockCodes')
path = os.path.join(gettempdir(), 'StockCodes.tex')
if not os.path.exists(path):
self.fail()
class ManagerLib(object):
_instance = None
def __new__(self):
if not self._instance:
self._instance = super(ManagerLib, self).__new__(self)
self.nse = Nse()
self.userList = []
return self._instance
#def __init__(self):
#self.nse = Nse()
#self.userList = []
def GetLiveData(self, key, id, stock):
ret = self.GetUser(key, id)
if isinstance(ret, UserDetails):
ret = self.nse.get_quote(str(stock))
return json.dumps(ret,
default=lambda o: o.__dict__,
sort_keys=True,
indent=4)
def CheckStockCode(self, key, id, stock):
ret = self.GetUser(key, id)
if isinstance(ret, UserDetails):
ret = self.nse.is_valid_code(str(stock))
return json.dumps(ret,
default=lambda o: o.__dict__,
sort_keys=True,
indent=4)
def GetListOfStocks(self, key, id):
ret = self.GetUser(key, id)
if isinstance(ret, UserDetails):
ret = self.nse.get_stock_codes()
return json.dumps(ret,
ensure_ascii=False,
default=lambda o: o.__dict__,
sort_keys=True,
indent=4)
def AddUser(self, key, firebase_url, firebase_pass):
firebaseauth = {
'FIREBASE_URL': firebase_url,
'FIREBASE_PWD': firebase_pass
}
userdetailobj = UserDetails(key, firebaseauth)
self.userList.append(userdetailobj)
ret = {
'message': 'User added successfully.',
'id': userdetailobj.userid
}
return json.dumps(ret,
default=lambda o: o.__dict__,
sort_keys=True,
indent=4)
def GetUsers(self):
return json.dumps(self.userList,
default=lambda o: o.__dict__,
sort_keys=True,
indent=4)
def GetUser(self, key, id):
userobj = list(x for x in self.userList if x.userid == id)
if userobj:
if userobj[0].userkey == key:
return userobj[0]
else:
return {'error': 'Id-key mismatch'}
else:
return {'error': 'Id not found'}
def GetUserDetails(self, key, id):
ret = self.GetUser(key, id)
return json.dumps(ret,
default=lambda o: o.__dict__,
sort_keys=True,
indent=4)
def AddConditionFieldList(self, key, id, indice, attrnames, attrtypes,
attrvalues, conjunctions, operations):
ret = self.GetUser(key, id)
if isinstance(ret, UserDetails):
ret = ret.SetConditionList(indice, attrnames, attrtypes,
attrvalues, conjunctions, operations)
return json.dumps(ret,
default=lambda o: o.__dict__,
sort_keys=True,
indent=4)
def AddSubscibeFieldList(self, key, id, conditionid, subscribeFieldlist,
triggermessage):
ret = self.GetUser(key, id)
if isinstance(ret, UserDetails):
conditionobjlist = list(condition
for condition in ret.conditionList
if condition.id == conditionid)
if conditionobjlist:
if not any(subscription
for subscription in ret.subscribeFieldList
if subscription.id == conditionid):
ret = ret.SetSubscibeFieldList(conditionobjlist[0].id,
conditionobjlist[0].indice,
subscribeFieldlist,
triggermessage)
else:
ret = {
'error':
'Subscription for the condition already present.Remove and then try.'
}
else:
ret = {'error': 'Condition id not found.'}
return json.dumps(ret,
default=lambda o: o.__dict__,
sort_keys=True,
indent=4)
def RemoveFromConditionList(self, key, id, conditionid):
ret = self.GetUser(key, id)
if isinstance(ret, UserDetails):
ret = ret.RemoveFromConditionList(conditionid)
return json.dumps(ret,
default=lambda o: o.__dict__,
sort_keys=True,
indent=4)
def RemoveFromSubscriptionList(self, key, id, subscriptionid):
ret = self.GetUser(key, id)
if isinstance(ret, UserDetails):
ret = ret.RemoveFromSubscriptionList(subscriptionid)
return json.dumps(ret,
default=lambda o: o.__dict__,
sort_keys=True,
indent=4)
def GetConditionList(self, key, userid):
ret = self.GetUser(key, id)
if isinstance(ret, UserDetails):
ret = ret.conditionList
return json.dumps(ret,
default=lambda o: o.__dict__,
sort_keys=True,
indent=4)
def GetSubscriptionList(self, key, userid):
ret = self.GetUser(key, id)
if isinstance(ret, UserDetails):
ret = ret.subscribeFieldList
return json.dumps(ret,
default=lambda o: o.__dict__,
sort_keys=True,
indent=4)
def RemoveUser(self, key, id):
ret = self.GetUser(key, id)
if isinstance(ret, UserDetails):
self.userList.remove(ret)
ret = {'message': 'User removed successfully'}
return json.dumps(ret,
default=lambda o: o.__dict__,
sort_keys=True,
indent=4)
def GetADByStockCode(self, stocklist):
AllAD = self.nse.get_advances_declines()
ret = list(x for x in AllAD if x['indice'] in stocklist)
return ret
def GetAllADStockCode(self):
AllAD = self.nse.get_advances_declines()
return list(x['indice'] for x in AllAD)
def CheckAttrNameOfStock(self, stock, attrname):
ret = GetAllDetailsOfStock(self, stock)
if attrname in ret:
return True
else:
return False
def CheckAttrTypeOfStock(self, stock, attrname, attrtype):
ret = GetAllDetailsOfStock(self, stock)
if attrtype == 'date':
try:
parse(ret[attrname])
return True
except:
return False
elif attrtype == 'number':
try:
float(ret[attrname])
return True
except:
return False
else:
return True
def CheckOperation(self, attrtype, operation):
if attrtype == 'string' and operation != 'equals':
return False
else:
return True
def SetStockList(self, stocklist):
self.stocklist = stocklist
def GetStockList(self):
return self.stocklist
def AddStock(self, stock):
self.stocklist.append(stock)
def RemoveStock(self, stock):
if len(self.stocklist) > 0 and stock in self.stocklist:
self.stocklist.remove(stock)
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)
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 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))
#import nsetools
from nsetools import Nse
nse = Nse()
print(nse)
q = nse.get_quote('infy') # it's ok to use both upper or lower case for codes.
from pprint import pprint # just for neatness of display
pprint(q)
nifty_quote = nse.get_index_quote(
'cnx nifty') # code can be provided in upper|lower case.
banknifty_quote = nse.get_index_quote(
'banknifty') # code can be provided in upper|lower case.
pprint(nifty_quote)
pprint(banknifty_quote)
all_stock_codes = nse.get_stock_codes()
pprint(all_stock_codes)
index_codes = nse.get_index_list()
pprint(index_codes)
adv_dec = nse.get_advances_declines()
pprint(adv_dec)
top_gainers = nse.get_top_gainers()
pprint(top_gainers)
nse.is_valid_code('infy') # this should return True
# get total number of rows
print("Total no. of Holding: %d" % (csvreader.line_num))
# printing the field names
#print('Field names are:\n' + ', '.join(field for field in fields))
investment = 0
totalinvestment = 0
for row in rows[:]:
# parsing each column of a row
stockName = row[0]
quantity = float(row[1])
avgPrice = float(row[2])
investment = quantity * avgPrice
totalinvestment += investment
if nse.is_valid_code(stockName):
nseStock = nse.get_quote(stockName)
daychange = ((float(nseStock["change"]) / nseStock['basePrice']) * 100)
PL = (float(nseStock["lastPrice"]) - avgPrice) * quantity
table.add_row([
stockName, quantity, avgPrice, nseStock["lastPrice"], investment,
PL, daychange
])
print("-------Total Investment---------=", totalinvestment)
print(table)
nse = Nse()
print(nse)
def printStocks(stocks):
class Stocks:
def __init__(self):
self.nse = Nse()
self.client = pymongo.MongoClient(
f"mongodb+srv://rachitahuja20:{DB_PASS}@cluster0.toqqc.mongodb.net/Cluster0?retryWrites=true&w=majority"
)
self.db = self.client.Stocks
self.bulk = self.db.Stocks_Historical.initialize_unordered_bulk_op()
def get_stock_value(self, ticker):
if self.nse.is_valid_code(ticker):
try:
q = self.nse.get_quote(ticker)
lastprice = q["lastPrice"]
return lastprice
except:
return None
else:
return None
def get_request(self, url, headers, timeout=(5, 25)):
start_time = time.time()
response = requests.get(url, timeout=timeout, headers=headers)
end_time = time.time() - start_time
return {'responsetime': end_time, 'response': response.text}
def lastTradedPrice(self, ticker):
url = 'https://www.nseindia.com/live_market/dynaContent/live_watch/get_quote/GetQuote.jsp?symbol=' + ticker + '&illiquid=0&smeFlag=0&itpFlag=0'.format(
ticker)
# url = "https://httpbin.org/user-agent"
headers = {
'User-Agent':
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.106 Safari/537.36',
"accept": "application/json"
}
try:
data_dict = self.get_request(url=url, headers=headers)
soup = BeautifulSoup(data_dict["response"], 'html.parser')
text = soup.find_all(id="responseDiv")[0].get_text()
LTP = re.search('(?<="lastPrice":).*?(?=}])',
text).group(0).replace('"', '')
return LTP
except Exception as e:
print("error", e)
def today_date(self):
date = datetime.datetime.today().strftime("%d-%m-%Y")
return date
def Mongo_Data_Push(self, ticker):
#data = self.lastTradedPrice(ticker)
data = self.get_stock_value(ticker)
date = str(self.today_date())
if data is not None:
self.bulk.find({"SYMBOL": ticker}).update({"$set": {date: data}})
def pipeline(self, ticker):
self.Mongo_Data_Push(ticker)
def get_list(self):
doc = self.db.Nse_Stocks_List.find()
for docs in doc:
return docs["List"]
#logging.debug('A debug message!')
#logging.info('A debug message!')
#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)
import nsepy
from nsetools import Nse
nse = Nse()
print(nse)
all_stock_codes = nse.get_stock_codes(cached=True)
print(all_stock_codes)
index_codes = nse.get_index_list(cached=True)
top_gainers = nse.get_top_gainers()
nse.is_valid_code('infy')
print(index_codes)
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)
df_info['Persistent']=Persistent
df_info['Cipla']=Cipla
df_info['Titan']=Titan
df_info['Sunpharma']=sunpharma
df_info['Hdfc']=Hdfc
df_info.rename(index={0:'dayLow',1:'dayHigh',2:'Open'}, inplace=True)
df_info=df_info.T
"""""
df_info['open']=q['open']
df_info['dayHigh']=q['dayHigh']
df_info['dayLow']=q['dayLow']
df_info['close']= q['closePrice']
"""
nse.is_valid_code('infy') # this should return True True
nse.is_valid_code('innnfy') # should return False False
nse.is_valid_index('cnx nifty') # should return True True
nse.is_valid_index('cnxnifty') # should return False False
nse.get_index_list()
nse.get_index_quote("nifty bank")
all_stock_codes = nse.get_stock_codes()
df_stock_codes=pd.DataFrame(all_stock_codes.items(), columns=['SYMBOL', 'NAME OF COMPANY'])
index_codes = nse.get_index_list()
pprint(index_codes)
df_index_codes=pd.DataFrame(index_codes)