def writeCodesToCSV(): nse = Nse() Index_Name = nse.get_index_list() # this return only name all_stock_codes = list(nse.get_stock_codes(cached=True).keys()) all_stock_name = list(nse.get_stock_codes(cached=True).values()) codes = [('SYMBOL', all_stock_codes), ('NAME', all_stock_name)] symbolDF = pd.DataFrame.from_items(codes) symbolDF['INDFLAG'] = 0 symbolDF['FO_FLAG'] = 0 symbolDF.to_csv(p.symbollist)
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 download_stock_data_method(**kwargs): nse = Nse() stock_names_dict = nse.get_stock_codes() stock_names_list = list(stock_names_dict.keys())[1:4] stocks = [] stocks = [ download_price_history_for_stock(symbol=stock) for stock in stock_names_list ] failed_stocks = [i for i in stocks if i] logging.info("Failed Stocks : ") logging.info(failed_stocks) failed_again = [] if len(failed_stocks) > 0: failed_again = [ download_price_history_for_stock(symbol=stock) for stock in failed_stocks ] if len(failed_again) > 0: logging.info("Failed STOCKS after multiple tries : ") logging.info(failed_again)
class NSE: def __init__(self): self.NSE = Nse() def getNSECompanyNames(self): NSECompanyCodes = self.NSE.get_stock_codes(cached=False) NSECompanyList = list(NSECompanyCodes.keys())[1:] return NSECompanyList
def stonkanalysis(start_date_year=2020, start_date_month=1, start_date_day=1, no_of_days=10, no_check_companies=1): ''' ''' # Initiate nse connection and get stock names nsel = Nse() stock_list = nsel.get_stock_codes() # Get the stock list stock_list = {v: k for k, v in stock_list.items()} no_of_comapies = len(stock_list) iterator = iter(stock_list.items()) break_cons = 0 company_list = [] company_code = [] # no of days should account for the holidays in between start_date = date(int(start_date_year), int(start_date_month), int(start_date_day)) end_date = start_date + timedelta(days=int(no_of_days)) print(start_date, end_date) for i in iterator: if break_cons >= 1: company_list.append(i[0]) company_code.append(i[1]) break_cons += 1 if break_cons == no_check_companies: break percentage_calc = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] stock_data = list(company_list) perc_matrix = [] summary_dic = {} volume_dict = {} mcap_dict = {} for i in range(len(stock_data)): data_frame = nse.get_history(symbol=company_list[i], start=start_date, end=end_date) #print(data_frame) volume_array = np.array(data_frame['Volume']) #print(volume_array) data_frame.drop(['VWAP', 'Series'], axis=1, inplace=True) if i == 0: no_of_days = len(np.array(data_frame['Close'])) perc_matrix = np.zeros( (int(no_of_days) - 1, len(percentage_calc), len(stock_data))) perc_matrix[:, :, i] = calculate_perc_matrix(data_frame, int(no_of_days), percentage_calc) stock_dict = {company_list[i]: perc_matrix.tolist()} summary_dic.update(stock_dict) print(summary_dic) return summary_dic
def index(request): nse = Nse() all_stock_codes = nse.get_stock_codes() stock_list = all_stock_codes.items() # row = nse_m_stocklist() # for stock in all_stock_codes.items(): # row.stock_code = stock[0] # row.stock_desc = stock[1] # row.save() # stock_list = nse_m_stocklist.objects.order_by('-stock_code') return render(request, 'nse/index.html', {'table': stock_list})
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 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
def additem(request, stockcode=None): if request.method == "POST": # This is form class form = nse_f_stocklist(request.POST) form.valid = True stockprice = 0. if form.is_valid(): post = form.save(commit=False) post.stock_type = 'SH' #post.user = '******' #post.stamp = datetime.datetime.now() post.save() updatesummary(post, 'buy') # Add data to summary table # try: # summary = nse_m_summarysheet.objects.get(stock_code = post.stock_code) # except: # summary = nse_m_summarysheet() ## summary = nse_m_summarysheet.objects.filter(stock_type = 'SH') ## summary_data = summary.filter(stock_code = post.stock_code) # if not summary.id: # summary_data = nse_m_summarysheet() # summary_data.stock_code = post.stock_code # summary_data.totbuyqty = float(post.buyqty) # summary_data.totbuyvalue = float(post.buyqty) * float(post.buyprice) # summary_data.avgbuyprice = float(post.buyprice) # summary_data.stock_type = 'SH' # # summary_data.currprice = post.currprice # # summary_data.currvalue = float(post.currprice) * float(post.buyqty) # summary_data.save() # else: # summary_data = nse_m_summarysheet(summary.id) # summary_data.stock_code = post.stock_code # summary_data.totbuyqty = float(summary.totbuyqty) + float(post.buyqty) # summary_data.totbuyvalue = float(summary.totbuyvalue) + (float(post.buyqty) * float(post.buyprice)) # summary_data.avgbuyprice = float(summary.totbuyvalue) / float(summary.totbuyqty) # summary_data.stock_type = 'SH' # # summary_data.currprice = post.currprice # # summary_data.currvalue = float(post.currprice) * float(summary_data.totbuyqty) # summary_data.save() return redirect('Stock_Summary') else: form = nse_f_stocklist() nse = Nse() all_stock_codes = nse.get_stock_codes() stock_list = all_stock_codes.items() return render(request, 'nse/additem1.html', { 'form': form, 'stock_list': stock_list })
class Command(BaseCommand): def __init__(self): self.company_details_repo = CompanyDetailsRepo() self.company_repo = CompanyRepo() self.nse = Nse() self.stockapi = NSE() def run(self): nse_list = self.nse.get_stock_codes() for code, title in nse_list.iteritems(): company = self.company_repo.filter(stockExchangeCode='NSE', code=code).first() if company: if company.weight < 1: print "saving: ", code, title company.weight += 1 company.save() else: print "creating: ", code, title try: details = self.company_details_repo.create(**{}) c = self.company_repo.create(details=details, **self._extract_company_data( title, code)) c.details = details c.save() c = self.stockapi.latest(c) except: print "error for " + title def _extract_company_data(self, name, code): return { "name": name, "code": code, #"quandlCode": data['dataset_code'], "description": name, "stockExchangeCode": 'NSE', "type": 'Time Series', "frequency": 'daily', "refreshedAt": helper.now(), #"oldestAvailableDate": helper.now(), "newAvailableDate": helper.now(), "history": [], "historyCount": 0, "weight": 1 }
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
class nseClass: def __init__(self): from nsetools import Nse self.nse = Nse() def createStockCodeNameCSV(self): ''' Creates a csv with 3 columns sl no, stock code name with stock name ''' self.all_stocks = self.nse.get_stock_codes() import csv with open('nse_code_name.csv', 'w', newline='') as file: self.writer = csv.writer(file) self.writer.writerow(["SN", "Code", "Name"]) for i, j in enumerate(self.all_stocks): if (i > 0): self.writer.writerow([i, j, self.all_stocks[j]])
def do(self): CommonCronJob.logger.info("Going to run stock index updater cron") nse = Nse() try: with transaction.atomic(): all_stock_codes = nse.get_stock_codes() all_stock_codes.pop('SYMBOL', None) models_to_create = [] for code, name in all_stock_codes.items(): models_to_create.append(Stock(code=code, name=name, updated_on=date.today())) Stock.objects.all().delete() Stock.objects.bulk_create(models_to_create) CommonCronJob.logger.info("Completed stock 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")
def __init__(self, Threads): from nsetools import Nse Nse = Nse() import requests import threading import json self.threading = threading # create a new variable for headers self.headers = { "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Ubuntu Chromium/80.0.3987.87 Chrome/80.0.3987.87 Safari/537.36" } # create a new array for stocks self.stocksArray = Nse.get_stock_codes() # create a new TCP Connection self.json = json # init an variable for number of threads self.threads = Threads self.s = requests.Session() print("initiated")
def dayopen(): nse = Nse() print(nse) companies_list = nse.get_stock_codes(cached=False) my_dict = companies_list w = csv.writer(open("stocklist.csv", "w", newline='')) for key, val in my_dict.items(): w.writerow([key, val]) stock_list = csv.reader(open('stocklist.csv')) next(stock_list) #creates new data frame final = pd.DataFrame() # dates configuration end_day = date.today() start_day = end_day - timedelta(365) for company in stock_list: try: symbol, name = company df1 = nse.get_quote(symbol.format(symbol), as_json=True) # df10 = nse.get_history(symbol.format(symbol), start=start_day, end=end_day,as_json=True) # datax = pd_json.loads(df10) # df11 = pd.json_normalize(datax) # df12 = pd.DataFrame(df11) data = pd_json.loads(df1) # load df = pd.json_normalize(data) # normalise df2 = pd.DataFrame(df) except: continue selected = df2.iloc[0:, [1, 6, 65, 11, 20, 67]] final = pd.concat([final, selected]) final = final.reset_index(drop=True) print(final) final.to_csv('dayopendata.csv', index=None, header=True)
def addwatchlistitem(request): if request.method == "POST": # This is form class form = nse_f_addwatchlititem(request.POST) form.valid = True if form.is_valid(): post = form.save(commit=False) post.stock_type = 'WL' #post.user = '******' #post.stamp = datetime.datetime.now() post.save() return redirect('Watch_List') else: form = nse_f_addwatchlititem() nse = Nse() all_stock_codes = nse.get_stock_codes() stock_list = all_stock_codes.items() return render(request, 'nse/addwatchlistitem.html', { 'form': form, 'stock_list': stock_list })
class get_all_stock_codes: """ This class will retrive all Stock codes from NSE website """ def __init__(self): self.all_stock_codes = [] self.nse = Nse() fileConfig('../properties/logging_config.ini') self.log = logging.getLogger() self.log.debug('Logger intiated ') def nsetools_get_codes(self, out_stock_file): """ This method retrivies all stock codes and write to CSV files Method uses NSETools to retrieve data from NSE website """ self.log.info("Retriving stock Codes from NSE site .. ") self.all_stock_codes = self.nse.get_stock_codes() df2 = pd.DataFrame.from_dict(self.all_stock_codes, orient='index') self.log.info("Total Stock Codes received :" + str(df2.shape[0])) df2.to_csv(out_stock_file)
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)
from nsetools import Nse from scripts import fetch from scripts import DB import json import tqdm db = DB.MongoDB() nse = Nse() all_codes = nse.get_stock_codes() for company_codes in tqdm.tqdm(list(all_codes.keys())[304 + 1052:]): _temp = {} try: det = fetch.company_info(company_codes + ".NS") if len(det) > 5: _temp["ticker"] = company_codes + ".NS" _temp["sector"] = det["sector"] _temp["name"] = all_codes[company_codes] _temp["previousClose"] = det["previousClose"] db.insert(_temp) except Exception: pass
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_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 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)
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)
def getstonkfocus(start_date_year=2020, start_date_month=1, start_date_day=1, no_of_days=10, no_check_companies=1, interest_period=3, interest_percentage=3): ''' ''' # Initiate nse connection and get stock names nsel = Nse() stock_list = nsel.get_stock_codes() # Get the stock list stock_list = {v: k for k, v in stock_list.items()} iterator = iter(stock_list.items()) break_cons = 0 company_list = [] company_code = [] # no of days should account for the holidays in between start_date = date(int(start_date_year), int(start_date_month), int(start_date_day)) end_date = start_date + timedelta(days=int(no_of_days)) print(start_date, end_date) for i in iterator: if break_cons >= 1: company_list.append(i[0]) company_code.append(i[1]) break_cons += 1 if break_cons == no_check_companies: break company_list.append('TATAMOTORS') stock_data = list(company_list) perc_matrix = [] summary_dic = {} for i in range(len(stock_data)): data_frame = nse.get_history(symbol=company_list[i], start=start_date, end=end_date) volume_array = np.array(data_frame['Volume']) print(volume_array) close_array = np.array(data_frame['Close']) data_frame.drop(['VWAP', 'Series'], axis=1, inplace=True) if i == 0: no_of_days = len(np.array(data_frame['Close'])) perc_matrix = np.zeros((1, 1, len(stock_data))) perc_matrix[:, :, i] = calculate_perc(data_frame, interest_period, interest_percentage) if (volume_array.size == 0): stock_dict = {company_list[i]: [perc_matrix[0, 0, i], 0, -1]} else: stock_dict = { company_list[i]: [ perc_matrix[0, 0, i], np.mean(volume_array), np.mean(close_array) ] } summary_dic.update(stock_dict) print(summary_dic) return summary_dic
class LoadCashDataFromNseTools: def __init__(self): self.nseClient = Nse() self.dbClient = motor.motor_asyncio.AsyncIOMotorClient(config.DB_HOST, config.DB_PORT) self.db = self.dbClient[config.DATABASE] self.collection = self.db[config.TEMP_COLLECTION] # <- TBD async def loadBhavdataToDB(self): entryCount = 0 updateCount = 0 skippedCount = 0 try: stockCodes = self.nseClient.get_stock_codes() sList = list(stockCodes.keys()) stockList = [] for stock in sList: stockList.append(stock) for stock in stockList[1:]: stockData = self.nseClient.get_quote(stock) # Convert to bhavData format bhavData = { 'date' : parser.parse(str(stockData['secDate']).strip()), # as a gatetime.date() object 'prevClose' : float(stockData['previousClose'] if (utils.is_number(stockData['previousClose'])) else '0.0'), 'openPrice' : float(stockData['open'] if (utils.is_number(stockData['open'])) else '0.0'), 'highPrice' : float(stockData['dayHigh'] if (utils.is_number(stockData['dayHigh'])) else '0.0'), 'lowPrice' : float(stockData['dayLow'] if (utils.is_number(stockData['dayLow'])) else '0.0'), 'lastPrice' : float(stockData['lastPrice'] if (utils.is_number(stockData['lastPrice'])) else '0.0'), 'closePrice' : float(stockData['closePrice'] if (utils.is_number(stockData['closePrice'])) else '0.0'), 'avgPrice' : float(stockData['averagePrice'] if (utils.is_number(stockData['averagePrice'])) else '0.0'), 'ttlTrdQtnty' : int(stockData['quantityTraded'] if (utils.is_number(stockData['quantityTraded'])) else '0'), 'turnoverLacs' : float(stockData['totalTradedValue'] if (utils.is_number(stockData['totalTradedValue'])) else '0.0'), # TBD #'noOfTrades' : int(stockData['noOfTrades'] if (utils.is_number(stockData['noOfTrades'])) else '0'), 'noOfTrades' : int('0'), 'delivQty' : int(stockData['deliveryQuantity'] if (utils.is_number(stockData['deliveryQuantity'])) else '0'), 'delivPer' : float(stockData['deliveryToTradedQuantity'] if (utils.is_number(stockData['deliveryToTradedQuantity'])) else '0.0') } dateList = [] document = await self.collection.find_one({'symbol': str(stockData['symbol']).strip()}) if document: for items in document['bhavData']: dateList.append(items['date']) if bhavData['date'] in dateList: # Data for this date is already present in Database skippedCount += 1 else: result = await self.collection.update_one({'symbol': str(stockData['symbol']).strip()}, {'$push': {'bhavData': bhavData}}) updateCount += 1 else: result = await self.collection.insert_one({'symbol': str(stockData['symbol']), 'bhavData': [bhavData]}) entryCount += 1 except Exception as e: print('loadBhavdataToDB () - ERROR : ', e) return entryCount, updateCount, skippedCount
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)
""" Created on Wed Oct 14 12:56:51 2015 @author: itithilien """ from nsetools import Nse import pandas as pd import time from urllib2 import build_opener, HTTPCookieProcessor, Request # 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)
def fetch_ticker_list(cls): nse = Nse() index_codes = nse.get_stock_codes() # pprint(index_codes) return index_codes
if answer is None: print ("Google Search") else: print (answer) elif "exit" in query: break elif "Stock" in query or 'stock' in query: #for using stockgogole-api stock = raw_input("Please tell me the exact stock name\n") St = nse.get_quote(stock) try: a = St['averagePrice'] b = St['buyPrice1'] c = St['sellPrice1'] print ("Average Price:"),a print ("BuyPrice:"),b print ('SellPrice:'),c except: s = raw_input("Please type correct Stock name, Should I tell you about avaiable Stocks?") if s=='yes': pprint (nse.get_stock_codes()) else: line = kernel.respond(query) for j in line.split("."): print (j)
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)
def getStockSymbols(all): nse = Nse() all_stock_codes = nse.get_stock_codes() print(all_stock_codes)
from nsetools import Nse from pprint import pprint import pandas as pd from tqdm import tqdm nse = Nse() stocks = list(nse.get_stock_codes().keys()) unwanted_stocks = [ 'SYMBOL', '3PLAND', 'ANKITMETAL', 'BURNPUR', 'CHROMATIC', 'CREATIVEYE', 'DCMFINSERV', 'EASTSILK', 'EUROMULTI', 'EUROTEXIND', 'EXCEL', 'GAYAHWS', 'GISOLUTION', 'GLOBOFFS', 'HBSL', 'INTEGRA', 'KALYANI', 'KAUSHALYA', 'MOHOTAIND', 'MOHITIND', 'MUKANDENGG', 'NAGREEKCAP', 'NAGREEKCAP', 'NATNLSTEEL', 'NIRAJISPAT', 'NORBTEAEXP', 'NTL', 'OMKARCHEM', 'PAEL', 'PRADIP', 'PREMIER', 'RADAAN', 'SABEVENTS', 'SHYAMTEL', 'SOMATEX', 'TECHIN', 'TFL', 'TGBHOTELS', 'VIVIDHA', 'YESBANK', 'ZICOM' ] stocks = [stock for stock in stocks if stock not in unwanted_stocks] price = [] company = [] symbol = [] for stock in tqdm(stocks[:10]): q = nse.get_quote(stock) if (q['deliveryToTradedQuantity'] is not None): if ((q['deliveryToTradedQuantity'] > 90)): company.append(q['companyName']) price.append(q['lastPrice'])
#imports from nsetools import Nse from datetime import datetime import json from pprint import pprint #initializations nse = Nse() i = 0 all_stock_codes = nse.get_stock_codes() #1626 with open('files/stock_data_min.json') as f : min_stock_data = json.load(f) # print(json.dumps(min_stock_data, indent=4, sort_keys=True)) # TODO: make this multithreaded for stock_code in all_stock_codes : try: stock_data = nse.get_quote(stock_code) except Exception as e: print(str(e), " for ", stock_code) continue today_date = datetime.today().strftime('%Y-%m-%d') data_for_today = {} data_for_today[today_date] = { "open": stock_data["open"], "high": stock_data["dayHigh"], "low" : stock_data["dayLow"], "close": stock_data["closePrice"]
from nsetools import Nse nse = Nse() allsocks = nse.get_stock_codes() stock_item = nse.get_quote('infy', as_json=False) print(type(stock_item))