def __init__(self, db = None, flush = False, Id = None, level = 'debug'):
uty.__init__(self)
self.Id = self.getId(Id)
lv.__init__(self, dumpFile = self.pathMaster['dumps'],
logFile = self.pathMaster['logs'],
Id = self.Id,
level = level)
self.auth = JSON.load(self.pathMaster['dbConfigs'])['redis']
self.redisStrcut = JSON.load(self.pathMaster['dbStruct'])['redis']
self.r = redis.Redis(host = self.auth['host'],
port = self.auth['port'],
password = self.auth['passWord'],
db = self.auth['db'] if db == None else self.redisStrcut[db])
if flush:
self.r.flushdb()
self.__setUp__()
def getMquote(self, quoteList):
result, reqParse = {}, {}
request = []
for seg in quoteList:
attr = self.brokerFunc['quoteIndex'] if seg[
-1] else self.brokerFunc['quoteSymbol']
param = self.__argParse__({
'symbol': seg[0],
'exg': seg[1]
}, attr['toGet'])
url = attr['endPoint'].format(urlencode(param))
request.append({
'url': url,
'enc': self.enc,
'eCode': [200, 500],
'headers': self.authHeader
})
reqParse[url] = [seg, attr['parse']]
resp = self.mRegular(urlList=request, ind=False)
for url, seg in reqParse.items():
result[seg[0]] = self.__blTul__(JSON.loads(resp[url]), seg[1])
return result
def __put__(self, kwargs):
"""
PUT cover for self.request
kwargs request Dict
return json-tested response
"""
resp = JSON.loads(
self.regular(url=kwargs['url'].format(urlencode(kwargs['query'])),
data=JSON.dumps(kwargs['data']),
method=kwargs['method'],
headers=self.authHeader,
enc=self.enc))
return self.__reqParse__(resp, kwargs)
def __POST__(self, kwargs):
"""
POST cover for self.request
kwargs request Dict
return json-tested response
"""
resp = JSON.loads(
self.regular(url=kwargs['endPoint'],
data=JSON.dumps(kwargs['data']),
method=kwargs['method'],
headers=self.authHeader,
enc=self.enc)[kwargs['endPoint']])
return self.__reqParse__(resp, kwargs)
def msgString(self, Dict):
r = ''
for k, v in Dict.items():
r += '{} = {}, '.format(k, JSON.dumps(v))
return r[:-2]
def __struct__(self, data, start, stop):
"""
data = json stringed data
start = start date in int
stop = stop date in int
return: to base data
"""
assoc = "yahoo:__struct__"
store = []
for rawData in data.values():
rawData = rawData.replace('null', '0.0')
res = JSON.loads(rawData)
error = res['chart']['error']
if error == 0.0:
root = res['chart']['result'][0]
if 'timestamp' in root.keys():
quote = root['indicators']['quote'][0]
timeStamp = root['timestamp']
for itr, each in enumerate(timeStamp):
if each >= start and each <= stop:
store.append(
(quote['open'][itr], quote['close'][itr],
quote['high'][itr], quote['low'][itr],
quote['volume'][itr],
time.strftime('%Y-%m-%d %H:%M:',
time.localtime(each)) + '00'))
## store.append((self.dec(quote['open'][itr]),
## self.dec(quote['close'][itr]),
## self.dec(quote['high'][itr]),
## self.dec(quote['low'][itr]),
## self.dec(quote['volume'][itr]),
## time.strftime('%Y-%m-%d %H:%M:', time.localtime(each)) + '00'))
else:
self.lv.eTrace(stamp=self.ts(),
assoc=assoc,
status="ERROR",
jsonRead="yahoo data not readable")
return store
def getInfo(self, symbolList):
"""
function for getting data associated wit ha symbol
symbolList = list of symbols for which data is required
return {symbol:data}
"""
statUrl = "https://www.nseindia.com/api/quote-equity?symbol={}"
urlMap, reqList = {}, []
result = {}
for sym in symbolList:
url = statUrl.format(sym)
reqList.append({'kwargs':{'url':url}, 'eCode':[200, 401]})
urlMap[url] = sym
for url, text in self.cPull(reqList).items():
_ = JSON.loads(text)
_ = [_['info']["companyName"],
_['info']["industry"],
_['info']["symbol"],
JSON.dumps(_['info']["activeSeries"]),
_["securityInfo"]["issuedCap"],
_['info']["isin"],
1 if _['metadata']['status'].lower() == "listed" else 0]
result[urlMap[url]] = _
return result
def __delete__(self, kwargs):
"""
DELETE cover for self.request
kwargs request Dict
return json-tested response
"""
resp = JSON.loads(
self.regular(url=kwargs['endPoint'].format(
urlencode(kwargs['query'])),
method=kwargs['method'],
headers=self.authHeader,
enc=self.enc)[kwargs['endPoint']])
return self.__reqParse__(resp, kwargs)
def __init__(self, Id=None, level='debug', **kwargs):
uty.__init__(self)
self.Id = self.getId(Id)
mDwn.__init__(self, Id=self.Id, level=level)
dwn.__init__(self, Id=self.Id, level=level)
self.mRegular([{'url': 'https://www.google.com/', 'enc': 'utf-8'}])
lv.__init__(self,
dumpFile=self.pathMaster['dumps'],
logFile=self.pathMaster['logs'],
Id=self.Id,
level=level)
self.brokerName = 'samco'
self.logStatus = False
self.defExg = 'NSE'
self.broker = JSON.load(self.pathMaster['brokers_'](self.brokerName +
'0.json'))
self.authHeader = {
'Content-Type': 'application/json',
'Accept': 'application/json'
}
self.intervalMap = {
'1m': 1,
'5m': 5,
'10m': 10,
'15m': 15,
'30m': 30,
'1h': 60,
'1d': None
}
self.__runBroker__()
self.creds = self.__argParse__(kwargs)
self.__login__()
def getQuote(self, symbolSeg):
"""
function for getting quote details from nse
symbolList list of segs for which symbol is requires [(symbol, exg, index:True/False)]
return {symbol:data}
"""
statUrl = "https://www.nseindia.com/api/quote-equity?symbol={}§ion=trade_info"
urlMap, reqList = {}, []
result = {}
_quoteReplace_ = {'totalBuyQuantity':'tbq',
'totalSellQuantity':'tsq',
'quantity':'qty',
'bid':'bidList',
'ask':'askList',
'totalTradedVolume':'ttVol',
'totalTradedValue':'ttVal',
'deliveryToTradedQuantity':'delPer'}
for seg in symbolSeg:
url = statUrl.format(seg[0])
reqList.append({'kwargs':{'url':url}, 'eCode':[200, 401]})
urlMap[url] = seg[0]
for url, text in self.cPull(reqList).items():
for bl, ul in _quoteReplace_.items():
text = text.replace(bl, ul)
result[urlMap[url]] = JSON.loads(text)
return result
def __get__(self, kwargs):
"""
GET cover for self.request
kwargs request Dict
return json-tested response
"""
url = kwargs['endPoint'].format(
urlencode(self.__argParse__(kwargs['data'], kwargs['toGet'])))
req = JSON.loads(
self.regular(url=url,
enc=self.enc,
eCode=[200, 500],
headers=self.authHeader)[url])
return self.__reqParse__(req, kwargs)
def __init__(self, Id=None, level='debug'):
uty.__init__(self)
self.Id = self.getId(Id)
self.rawSchema = JSON.load(self.pathMaster['dbStruct'])['mySql']
self.db = 'create database if not exists {};'
self.tab = 'create table if not exists {}.{} {};'
self.col = 'show columns from {}.{};'
self.cCol = 'alter table {}.{} add column {} {};'
self.aCol = 'alter table {}.{} modify {} {};'
self.strip = lambda string: string.replace(' ', '').split('=>')[1]
self.lStrip = lambda string: string.replace(' ', '').split('=>')
self.mRoute = lambda string, node: '{}.{}'.format(string, node)
self.nMap = {}
self.__load__()
def pushIndices(self):
rawData = self.getIndices(content=True)
#rawData = JSON.load('test.json')
symStore, indStore = [], []
for secInd, symSeg in rawData.items():
isins = []
for symInfo in symSeg:
isins.append(symInfo[4])
symInfo = list(symInfo)
symInfo.append(self.exgId)
symStore.append(tuple(symInfo))
indStore.append((secInd[0], secInd[1], JSON.dumps(isins),
self.dbId(), self.exgId))
symStore = str(symStore)[1:-1]
indStore = str(indStore)[1:-1]
with self.db as cu:
cu.execute(
f"replace into `symStore` (`symCmp`, `symSec`, `sym`, `symSeg`, `symId`, `ESId`) values {symStore};"
)
cu.cnx.commit()
cu.execute(
f"replace into `indStore` (`indSec`, `ind`, `indCont`, `indId`, `EIId`) values {indStore};"
)
cu.cnx.commit()
def __init__(self, asy=False, Id=None, level='debug'):
uty.__init__(self)
self.Id = self.getId(Id)
self.asy = asy
self.level = level
self.auth = JSON.load(self.pathMaster['dbConfigs'])['mySql']
self.auth = {
'userName': self.auth['userName'],
'passWord': self.auth['passWord'],
'host': self.auth['host'],
'port': self.auth['port']
}
self.varForm = '`{}`'
self.schema = schema()
self.nMap = self.schema.nMap
self.makeSchema = self.schema.create
def __init__(self, Id=None, level='debug', **kwargs):
"""
userName = samco userName
password = samco passWord
code = samco code
don't disarrage variables variables are position dependent
"""
uty.__init__(self)
self.Id = self.getId(Id)
lv.__init__(self,
dumpFile=self.pathMaster['dumps'],
logFile=self.pathMaster['logs'],
Id=self.Id,
level=level)
dwn.__init__(self, Id=self.Id, level=level)
mDwn.__init__(self, self.Id, level)
self.brokerName = 'samco'
self.brokerBase = "https://api.stocknote.com"
self.logStatus = False
self.defExg = 'NSE'
self.broker = JSON.load(self.pathMaster['brokers_'](self.brokerName +
'0.json'))
self.checkList = {}
self.authHeader = {
'Content-Type': 'application/json',
'Accept': 'application/json'
}
self.reqRoute = {
'GET': self.__GET__,
'POST': self.__POST__,
'PUT': self.__PUT__,
'DELETE': self.__DELETE__
}
self.intervalMap = {
'1m': 1,
'5m': 5,
'10m': 10,
'15m': 15,
'30m': 30,
'1h': 60,
'1d': None
}
self.__runBroker__()
self.creds = self.__argParse__(kwargs)
self.__login__()
def getSymbols(self):
"""
funcion for getting all symbols currently active on nse
return [(data), (data)]
"""
assoc = "nse:getSymbols"
statUrl = "https://archives.nseindia.com/content/equities/EQUITY_L.csv"
ts = self.ts()
self.mTrace(stamp = ts, assoc = assoc, status = "GET")
rawCsv = self.regular(url = statUrl, enc = self.enc)[statUrl]
symHeads = ['NAME OF COMPANY', 'SYMBOL', 'SERIES', 'ISIN NUMBER']
baseElem = self.csvBase(rawCsv, headers = symHeads, ff = lambda _ : [_[0], self.splString(_[1]), JSON.dumps([_[2]]), _[3]])
self.mTrace(stamp = self.td(ts), assoc = assoc, status = "SUCCESS", lot = len(baseElem))
return baseElem
def updIndices(self, upd=False):
"""
updates indexList and index Content List
creates table for index if not present
"""
"""
to make consistency with all status driven function upd has been added
"""
assoc = "nseUpd:updIndices"
ts = self.ts()
self.mTrace(stamp=ts, assoc=assoc, status="GET", upd=upd)
symStore, indStore = [], []
if upd:
rawData = self.getIndices(content=True)
for secInd, symSeg in rawData.items():
isins = []
for symInfo in symSeg:
isins.append(symInfo[4])
symInfo = list(symInfo)
symInfo.append(self.exgId)
symStore.append(tuple(symInfo))
indStore.append((secInd[0], secInd[1], JSON.dumps(isins),
self.dbId(), self.exgId))
symStore = str(symStore)[1:-1]
indStore = str(indStore)[1:-1]
with self.db as cu:
cu.execute(
f"""insert into `symStore` (`symCmp`, `symSec`, `sym`, `symSeg`, `symId`, `ESId`)
values {symStore}
on duplicate key update
`symCmp` = values(`symCmp`),
`symSec` = values(`symSec`),
`sym` = values(`sym`),
`symSeg` = values(`symSeg`),
`symId` = values(`symId`),
`ESId` = values(`ESId`));""")
cu.cnx.commit()
cu.execute(
f"""insert into `indStore` (`indSec`, `ind`, `indCont`, `indId`, `EIId`)
values {indStore}
on duplicate key update
`indSec = values(`indSec`),
`ind` = values(`ind`),
`indCont` = values(`indCont`),
`intId` = values (`indId`),
`EIId` = values(`EIId`);""")
cu.cnx.commit()
self.mTrace(stamp=self.td(ts), assoc=assoc, status="GET", upd=upd)