def reply_handler(msg):
if msg.typeName == 'realtimeBar' or msg.typeName == 'updateMktDepth' or msg.typeName == 'tickPrice' or msg.typeName == 'tickSize' or msg.typeName == 'tickString':
msgarray = (str(msg)).split()
reqid=(msgarray[1]).split('=')[1].replace(',','')
sym=symTickerIddict[reqid]
onerow = (str(msg)).split(',')
timenow= datetime.now().time().isoformat()
ticktime = timenow.replace(':','').replace('.','')
if msg.typeName == 'realtimeBar':
fname = DataDown+ today + '.' + sym +'.rtimebar.' + ticktime+'.txt'
cleanonerow = Mod_TicksUtile.clean_RTTick5secBars(onerow,sym)
rpu_rp.WriteArrayToCsvfile(fname,[cleanonerow])
rpu_rp.WriteArrayToCsvfile(DataDown +today+'.'+sym+ '.RTtickslastquote.csv',[cleanonerow])
elif msg.typeName == 'updateMktDepth':
fname = DataDown+ today + '.' + sym +'.rtDOMbar.' + ticktime+'.txt'
cleanonerow = Mod_TicksUtile.clean_rtDOMbar(onerow,sym)
rpu_rp.WriteArrayToCsvfile(fname,[cleanonerow])
rpu_rp.WriteStringsToFileAppend(TMP +'replys.RTticks',str(msg))
elif msg.typeName == 'tickPrice' or msg.typeName == 'tickSize' :
fname = DataDown+ today + '.' + sym +'.rtTICKbar.' + ticktime+'.txt'
cleanonerow = Mod_TicksUtile.clean_rtTICKbar(onerow,sym)
rpu_rp.WriteArrayToCsvfile(fname,[cleanonerow])
rpu_rp.WriteStringsToFileAppend(TMP +'replys.RTticks',str(msg))
elif msg.typeName == 'tickString' :
## fname = DataDown+ today + '.' + sym +'.rtTICKStringsbar.' + ticktime+'.txt'
## cleanonerow = Mod_TicksUtile.clean_rtTICKbar(onerow,sym)
## rpu_rp.WriteArrayToCsvfile(fname,[cleanonerow])
rpu_rp.WriteStringsToFileAppend(TMP +'replys.RTticksStrings',str(msg))
else:
print str(msg) ## still need the TickString and Generic typeNames
rpu_rp.WriteStringsToFileAppend(TMP +'replys.RTticks',str(msg))
def create_statesdaily():
for sym in symbol_list:
for barsize in barlist :
timeframe = bardict[barsize]
durinseconds = secdict[barsize]
barsizeNtimeframe = timeframe + barsize
dur = barsize
TicksUtile.assemble_dur_bars(today,sym,dur,durinseconds)
DurBoth = rpu_rp.CsvToLines( DataDown+ today + '.'+sym+'.' + dur.replace(' ','') + '.both.csv')
indlist = ['pivot', 'R', 'S', 'S2', 'R2']
for indicator in indlist:
## print sym
indarr = rpInd.GetPivots(DurBoth,sym,indicator)
statename = sym+'.'+dur.replace(' ','')+'.'
statefile = statearea +statename + indicator + '.state.csv'
rpu_rp.WriteArrayToCsvfile(statefile, indarr)
indlist2 = ['kupper', 'klower', 'kmid']
for indicator in indlist2:
## print indicator
indarr = rpInd.GetKupper(DurBoth,sym,indicator)
statename = sym+'.'+dur.replace(' ','')+'.'
statefile = statearea +statename + indicator + '.state.csv'
rpu_rp.WriteArrayToCsvfile(statefile, indarr)
## keltner_channel_upper(highs,lows,closes,mult)
indlist3 = ['ema']
for indicator in indlist3:
## print indicator
indarr = rpInd.GetEMA(DurBoth,sym,indicator)
statename = sym+'.'+dur.replace(' ','')+'.'
statefile = statearea +statename + indicator + '.state.csv'
rpu_rp.WriteArrayToCsvfile(statefile, indarr)
def createOneMerge(dur, now, sym, date):
now_epoch = int(time.mktime(time.strptime(now, spaceYtime_format)))
## print '##### ', dur, sym,' ####### '
durinseconds = secdict[dur]
basisdur = '1min'
if dur == '1min':
basisdur = '5secs'
basisfile = DataDown + date + '.' + sym + '.' + basisdur + '.both.csv' ### this bit not used yet until expand startmode
basisbars = rpu_rp.CsvToLines(basisfile)
filerecent = DataDown + date + '.' + sym + '.' + dur + '.recent' + '.csv'
if dur != '5secs':
recentbars = Mod_TicksUtile.create_bars_from_bars(
basisbars, date, sym, dur, durinseconds, 'noHA')
rpu_rp.WriteArrayToCsvfile(filerecent, recentbars)
## now merge recent and both
fileddload = filerecent.replace('recent', 'ddload')
outfile = filerecent.replace('recent', 'both')
cutoffmintime = int(int(durinseconds) - 5)
if os.path.isfile(filerecent):
Mod_TicksUtile.merge_bar_files(filerecent, fileddload, outfile,
cutoffmintime)
else:
shutil.copyfile(fileddload, outfile)
## print 'found no ddload file so did no merge'
##########
basisfile = DataDown + date + '.' + sym + '.' + dur + '.both.csv' ### note the basis dur changed to just dur!!
basisbars = rpu_rp.CsvToLines(basisfile)
HAbars = Mod_TicksUtile.create_bars_from_bars(basisbars, date, sym, dur,
durinseconds, 'hamode')
## print 'done creating HA bars'
fileHABoth = DataDown + date + '.' + sym + '.' + dur.replace(
' ', '') + '.bothHA' + '.csv'
rpu_rp.WriteArrayToCsvfile(fileHABoth, HAbars)
def backupTickfiles(fname1):
fname2 = fname1.replace('.csv', 'bu.csv')
f1 = rpu_rp.CsvToLines(fname1)
f2 = rpu_rp.CsvToLines(fname2)
for line in f1:
f2.append(line)
rpu_rp.WriteArrayToCsvfile(fname2, f2)
rpu_rp.WriteArrayToCsvfile(fname1, [])
def chopMonthToDays(bararray,sym,dur,secs): ### what does this do?
lines = bararray
print secs
preve = 0
prevfname = 0
ubars =[]
uubars =[]
diffprev = 1
daylist =[]
for l in lines:
if len(l) > 2:
timestring = l[1]
date = timestring[0:11]
daylist.append(date)
daylistu = rpu_rp.uniq(daylist)
for day in daylistu:
daysarray=[]
for l in bararray:
if day in l[1] :
timestring = l[1]
try:
e = TicksUtile.convertTime(timestring,'dashspace','timetoepoch')
except:
e = TicksUtile.convertTime(timestring,'dashspace','timetoepoch')
diffcur = e - preve
preve = e
## print diffcur,timestring
if diffcur == int(secs):
daysarray.append(l)
## print l
print day, sym,dur, len(daysarray)
fileoutname = DataDown + day +'.' + sym +'.' + dur+'.cleaned.csv'
rpu_rp.WriteArrayToCsvfile(fileoutname, daysarray)
def verify_bars(barfile):
fileoutname = 'barsout.csv'
lines = rpu_rp.CsvToLines(barfile)
print barfile, 'needs verify'
dur = barfile.split('.')[2]
sym = barfile.split('.')[1]
print dur
durinseconds = int(secdict[dur])
print dur, durinseconds
preve = 0
prevfname = 0
ubars =[]
uubars =[]
diffprev = 1
for l in lines:
if len(l) > 2:
timestring = l[1]
e = TicksUtile.convertTime(timestring,'dashspace','timetoepoch')
diffcur = e - preve
## print diffcur
if diffcur != durinseconds:
print sym,dur,diffcur, durinseconds,l
ubars.append(l)
else:
pass
preve = e
prevline = l
diffprev = diffcur
rpu_rp.WriteArrayToCsvfile(fileoutname, ubars)
## for b in ubars:
## print b
return ubars
def start_tickers():
symTickerIddict = {}
contractdict = {}
reqID = 1
symid = 1
for sym in symbol_list2:
print sym, symid
fname1 = DataDown + today + '.' + sym + '.RTticks.csv'
## backup the tick files before restarting
backupTickfiles(fname1)
## flush the tickfile
rpu_rp.WriteArrayToCsvfile(fname1, [])
### restart ticker
##build the cntract dict but probably not use
contract = ibutiles.create_ticksym(symid, sym)
contractdict.update({sym: contract})
symTickerIddict.update({str(symid): sym})
print symTickerIddict
ticktype = ticktypedict[sym]
## restart the ticker
tws_conn.reqRealTimeBars(reqID, contract, '', ticktype, 0)
symid += 1
reqID += 1
sleep(1)
def CreateIndvalueTable(indlist, durlist, symlist, filename):
mmarrayfull = []
#### def StdToArray(arrayin,smavalstd)
## indlist = indlist_All#['ROC', 'mcross']
print 'minval,maxval,avg,AbsAvg,std1,MinvalNegs,MaxvalNegs,minvalPoss,maxvalPoss'
stdvariable = 1 ###add this to a table to make diff for each ind and to get more foo
for sym in symlist:
for dur in durlist:
for ind in indlist:
mmarray = []
## t = MaxMinAvgIndArray(sym,dur,ind,1)
## t = MaxStdAvgIndArray(sym,dur,ind,1)
t = StatesArrayToAllStats(sym, dur, ind, 1)
tarray = list(t)
print tarray, sym, dur, ind
midpoint = 0 # round(tarray[2],4)
maxval = round(tarray[1], 4) # this gives max
maxval = stdvariable * round(
tarray[4], 4) #this gives the std rather than max
stdvalue = 1 * round(tarray[4],
4) #this gives the std rather than max
mmarray.append(ind)
mmarray.append(dur)
mmarray.append(
midpoint) ## this is the midpoint level, normally 0
mmarray.append(
maxval) ## this is the max abs value for 80% rules
## mmarray.append(tarray[0]) ## is minvalue
mmarray.append('slopenormal')
mmarray.append('PCompareNormal')
mmarray.append(sym)
mmarray.append(stdvalue)
mmarrayfull.append(mmarray)
## print mmarrayfull
rpu_rp.WriteArrayToCsvfile(filename, mmarrayfull)
def convert_xlsx_newsage_csv(filename,style):
## rpu_rp.convertXLSXtoCSV(infile)
outfile = infile.replace('xlsx','csv')
outfilenew = infile.replace('xlsx','new.csv')
lines = rpu_rp.CsvToLines(outfile)
newfile =[]
cl=0
for l in lines:
numflds = len(l)
c=0
newline =[]
if style == 'incstyle':
for col in l:
if c == 7 or c == 21 or c == 22:
pass
else:
newline.append(col)
c+=1
newfile.append(newline)
cl +=1
else:
for col in l:
if c == 7 or c == 21 or c == 22 or c==10 or c== 11:
pass
else:
newline.append(col)
c+=1
## print newline
newfile.append(newline)
cl +=1
print 'wrting new file'
rpu_rp.WriteArrayToCsvfile(outfilenew, newfile)
def reply_handler(msg):
if msg.typeName == 'realtimeBar':
msgarray = (str(msg)).split()
## print msgarray, 'rawmessg'
reqid = (msgarray[1]).split('=')[1].replace(',', '')
## fieldnum = (msgarray[2]).split('=')[1].replace(',','')
sym = symTickerIddict[reqid]
onerow = (str(msg)).split(',')
## print onerow,'onerow split by comma'
timenow = datetime.now().time().isoformat()
## print msg.typeName, sym, timenow
if msg.typeName == 'realtimeBar':
cleanonerow = TicksUtile.clean_RTTick5secBars(onerow, sym)
rpu_rp.WriteArrayToCsvfileAppend(
DataDown + today + '.' + sym + '.RTticks.csv', [cleanonerow])
rpu_rp.WriteArrayToCsvfile(
DataDown + today + '.' + sym + '.RTtickslastquote.csv',
[cleanonerow])
######## elif msg.typeName == 'tickString' or msg.typeName == 'tickSize' or msg.typeName == 'tickPrice' :
######## onerow.append(timenow)
######## rpu_rp.WriteArrayToCsvfileAppend(DataDown +today+'.'+sym+ '.RTtickData.csv',[onerow])
######## elif msg.typeName == 'updateMktDepth':
######## onerow.append(timenow)
######## rpu_rp.WriteArrayToCsvfileAppend(DataDown +today+'.'+sym+ '.RTMktDepth.csv',[onerow])
else:
print str(msg)
rpu_rp.WriteStringsToFileAppend(TMP + 'replys.RTticks', str(msg))
def create_dailypivots(sym):
pivot = round(float(rpInd.gatherline(sym, 'pivot')[1]), 1)
R1 = round(float(rpInd.gatherline(sym, 'R1')[1]), 1)
S1 = round(float(rpInd.gatherline(sym, 'S1')[1]), 1)
S2 = round(float(rpInd.gatherline(sym, 'S2')[1]), 1)
R2 = round(float(rpInd.gatherline(sym, 'R2')[1]), 1)
## print S1,R1,pivot
##do the same for weekly by adding dur to variables and create a weekly from dailys..
## find pivots, find fibbo retraces on recnt moves[rangebars,hi,lo]
## calculate 10 handles off high of day,lowday,openday,yestclose,prevhourhilow
outfile = libarea + 'spotlinesAutopivot.' + sym + '.csv'
itemlist = [pivot, R1, S1, S2, R2]
itemlisttags = ['pivotRP', 'R1rp', 'S1rp', 'S2rp', 'R2rp']
lines = []
c = 0
for item in itemlist:
tag = itemlisttags[c]
c += 1
line = []
line.append(item)
line.append(tag)
lines.append(line)
for line in lines:
print line
rpu_rp.WriteArrayToCsvfile(outfile, lines)
def assemble_lines(sym,barsize,barsizeNtimeframe):
## print sym, barsize,barsizeNtimeframe
totalsecs = secdict[barsize]
timebarforsnaps = barsize
import datetime as dt
htickfile = DataDown+ today + '.'+sym+'.' + barsize + '.csv' #[date 5 mins.2 D.GBP.csv
Snaptickfile = DataDown + today + '.' + sym + '.ticksnaps.csv'
SnapBarsFname = DataDown + today + '.' + barsize + '.' + sym + '.SnapBars.csv'
Sigfile = sigarea + sym +'.sigs.csv'
snaplines = rpu_rp.CsvToLines(Snaptickfile)
lline = 'ES, 2015-06-10 00:22:00, 2080.25, 2080.5, 2080.25, 2080.5, -1'
try:
lastline = rpu_rp.tail_to_txtfile(htickfile,2,'outfile') ## get last line of historical file for time check
pass
except:
lastline = lline
lastlineof_hticks = rpu_rp.catstring('outfile') ## this is the last line
try:
timeofbar = (lastlineof_hticks.split(',')[1]).split()[1]
except:
timeofbar ='23:59:58'
time_of_last_hbar_dt = dt.datetime.strptime(timeofbar, time_format)
snapbars = rpInd.create_bars(snaplines,50000,totalsecs,'fullbar','snapshot', sym,time_of_last_hbar_dt,SnapBarsFname)# also creates a file
rpu_rp.WriteArrayToCsvfile(DataDown+today + '.' + sym + '.'+ barsize + '.recent.csv',snapbars)
lines = createlines(htickfile)
decimalboost = dboostdict[sym]
return lines
def prepare_imp_file(filein, fileout):
newlines = []
lines = rpu_rp.CsvToLines(filein)
headerline = [
'Action', 'Quantity', 'Symbol', 'TimeInForce', 'SecType', 'OrderType',
'LmtPrice', 'Exchange', 'Currency', 'CUSIP', 'ISIN', ''
]
## itemlist = [Action, Quantity, Symbol, TimeInForce, SecType, OrderType, LmtPrice, Exchange, Currency, CUSIP, ISIN]
newlines.append(headerline)
for l in lines:
newline = []
print l
isin = l[6]
action = l[0]
title = l[3]
qty = l[5]
price = l[2]
c = 0
for i in headerline: # itemlist:
## print i
## newline.append(i)
newline.append(l[c])
c += 1
newlines.append(newline)
rpu_rp.WriteArrayToCsvfile(fileout, newlines)
def prepare_imp_file(filein, fileout):
newlines = []
lines = rpu_rp.CsvToLines(filein)
headerline = [
'Action', 'Quantity', 'Symbol', 'TimeInForce', 'SecType', 'OrderType',
'LmtPrice', 'Exchange', 'Currency', 'CUSIP', 'ISIN', ''
]
headerline = [
'name', 'valor', 'roloid', 'isin', 'sugarid', 'tradedcurr',
'assetclass', 'sector'
]
newlines.append(headerline)
for l in lines:
newline = []
newlinebla = []
isin = l[11]
roloid = l[10]
name = l[0]
sugarid = l[1]
valor = l[23]
tradedcurr = l[29]
exchname = l[40]
assetclass = l[57]
sector = l[59]
c = 0
for i in headerline:
newvar = locals()[i]
if newvar == 'isin':
print newvar
newline.append(newvar)
newlines.append(newline)
rpu_rp.WriteArrayToCsvfile(fileout, newlines)
def process_ticks(lines, sym, dur):
bs = strip1float(lines, 5, sym) ##raw close price
bshighs = strip1float(lines, 3, sym)
bslows = strip1float(lines, 4, sym)
timestamparray = strip1string(lines, 1)
symarray = strip1string(lines, 0)
sym = symarray[1]
durarray = []
for b in symarray:
durarray.append(dur)
### create pivots rs and ss ###
piv = pivotpoint(bs, bshighs, bslows)
## R1 = R1(piv,bshighs)
########################################
signbs = show_sign(bs, 'price')
slopebs = show_slope(bs, 'price')
##### MA Cross ##
macrossval = difftwoarrays(EMAmvavgToArray(bs, 9), EMAmvavgToArray(bs, 21))
signmcd = show_sign(macrossval, 'mcd')
crossesmcd = show_crossover(signmcd, 'mcd')
slopemcd = show_slope(macrossval, 'mcd')
MDarray = makearrayJust2(timestamparray, symarray, durarray, bs,
macrossval, crossesmcd, signmcd)
ma = rpu_rp.grep_array_to_array(MDarray, 'cross')
rpu_rp.WriteArrayToCsvfile(
sigarea + today + '.' + sym + '.' + dur + '.sigs.csv', ma)
rpu_rp.WriteArrayToCsvfileAppend(sigarea + today + '.sigs.csv',
[ma[len(ma) - 1]])
return ma
def prepare_imp_file(filein,fileout):
newlines =[]
lines = rpu_rp.CsvToLines(filein)
headerline =['Action', 'Quantity', 'Symbol', 'TimeInForce', 'SecType', 'OrderType', 'LmtPrice', 'Exchange', 'Currency', 'CUSIP', 'ISIN', '']
headerline =['name', 'roloid', 'isin', 'sugarid', 'tradedcurr', 'assetclass','sector']
headerline =['module','resultmodule','QorA','QuestionNum','AnswerNum','AnswerScore','ScoreMethod','PrivateORGRelevant','QAType','QtextID',' English','German','French','notes']
newlines.append(headerline)
for l in lines:
## print l
newline =[]
newlinebla =[]
isin = l[1]
c=0
for i in headerline:
locals()[i] = l[c]
if locals()[i] == 'Q' and c==2:
print i,locals()[i]
## print l
qtextid = l[9]
print qtextid
newvar=locals()[i]
newline.append(newvar)
c+=1
newlines.append(newline)
rpu_rp.WriteArrayToCsvfile(fileout,newlines)
def historical_data_handler(msg):
global newDataList
## arrayout = []
fname = DataDown + today + '.' + sym + '.' + bar.replace(
' ', '') + '.ddload.csv'
if ('finished' in str(msg.date)) == False: ### keep building the list
## print (int(msg.date))
fstring = "%Y-%m-%d %H:%M:%S"
dateold = localtime(int(msg.date))
tdate = strftime(fstring, dateold)
if bar == '1 day':
tdate = str((int(msg.date))) + ' 23:59:58'
dataStr = '%s, %s, %s, %s, %s, %s, %s' % (
sym, tdate, msg.open, msg.high, msg.low, msg.close, msg.volume)
## if msg.typeName == 'open':
## lineout =[]
## lineout.append(sym)
## lineout.append(tdate)
## lineout.append(msg.open)
## lineout.append(msg.high)
## lineout.append(msg.low)
## lineout.append(msg.close)
## lineout.append(msg.volume)
## arrayout.append(lineout)
newDataList = newDataList + [dataStr]
else:
print 'next list'
if os.path.isfile(fname):
os.remove(fname) #flush the file
rpu_rp.WriteArrayToCsvfile(fname, arrayout)
## for a in newDataList:
## rpu_rp.WriteStringsToFileAppend(fname,a)
newDataList = []
def assemble_dur_bars(today, sym, dur, startmode, basisdur, hamode):
durinseconds = secdict[dur]
basisfile = DataDown + today + '.' + sym + '.' + basisdur + '.both.csv' ### this bit not used yet until expand startmode
basisbars = rpu_rp.CsvToLines(basisfile)
if hamode == 'hamode':
create_HAbars_from_bars(basisbars, today, sym, dur, durinseconds,
startmode) ## creates recentfile
newbars = create_HAbars_from_bars(basisbars, today, sym, dur,
durinseconds,
startmode) ## creates recentfile
bartypetag = '.HA'
else:
newbars = create_bars_from_bars(basisbars, today, sym, dur,
durinseconds,
startmode) ## creates recentfile
bartypetag = ''
## for b in newbars:
## print b
file1 = DataDown + today + '.' + sym + '.' + dur.replace(
' ', '') + '.ddload' + bartypetag + '.csv'
filetempdl = DataDown + today + '.' + sym + '.' + dur.replace(
' ', '') + '.tempdurs' + bartypetag + '.csv'
rpu_rp.WriteArrayToCsvfile(filetempdl, newbars)
file2 = DataDown + today + '.' + sym + '.' + dur.replace(
' ', '') + '.recent' + bartypetag + '.csv'
outfile = DataDown + today + '.' + sym + '.' + dur.replace(
' ', '') + '.both' + bartypetag + '.csv'
cutoffmintime = int(int(durinseconds) - 5)
if os.path.isfile(file1):
## merge_bar_files(file1,file2,outfile,cutoffmintime)
merge_bar_files(file1, file2, outfile, cutoffmintime)
## print 'merging ars',file1
else:
shutil.copyfile(file2, outfile)
def create_state_files(today, sym, dur, indicator):
outfile = DataDown + today + '.' + sym + '.' + dur.replace(
' ', '') + '.' + indicator + 'state.csv'
infile = DataDown + today + '.' + sym + '.' + dur.replace(' ',
'') + '.both.csv'
arrayin = rpu_rp.CsvToLines(infile)
arrayout = rpInd.GetStates(arrayin, sym, indicator)
rpu_rp.WriteArrayToCsvfile(outfile, arrayout)
def reply_handler(msg):
if msg.typeName == 'realtimeBar':
msgarray = (str(msg)).split()
reqid = (msgarray[1]).split('=')[1].replace(',', '')
sym = symTickerIddict[reqid]
onerow = (str(msg)).split(',')
timenow = datetime.now().time().isoformat()
ticktime = timenow.replace(':', '').replace('.', '')
fname = DataDown + today + '.' + sym + '.rtimebar.' + ticktime + '.txt'
cleanonerow = Mod_TicksUtile.clean_RTTick5secBars(onerow, sym)
rpu_rp.WriteArrayToCsvfile(fname, [cleanonerow])
rpu_rp.WriteArrayToCsvfile(
DataDown + today + '.' + sym + '.RTtickslastquote.csv',
[cleanonerow])
else:
print str(msg)
rpu_rp.WriteStringsToFileAppend(TMP + 'replys.RTticks', str(msg))
def create_bars_files(sym,dur,date,threshold,newindlist):
print dur
durinseconds = secdict[dur]
DurBoth = rpu_rp.CsvToLines( DataDown+ date + '.'+sym+'.' + dur.replace(' ','') + '.both.csv')
DurBothBoosted = boost_pricearray(DurBoth,sym)
for indicator in newindlist:
indarr = GetBars(DurBothBoosted,sym,indicator,dur,threshold)
statename = sym+'.'+dur.replace(' ','')+'.'
statefile = statearea +statename + indicator + '.bars.csv'
rpu_rp.WriteArrayToCsvfile(statefile, indarr)
def throw_out_lastbar(f):
## f = DataDown+ date + '.' + sym + '.' + dura.replace(' ','') +'.ddload.csv'
lines = rpu_rp.CsvToLines(f)
c = 0
newarr = []
for l in lines:
c += 1
if c < len(lines):
newarr.append(l)
rpu_rp.WriteArrayToCsvfile('tmp', newarr)
shutil.copyfile('tmp', f)
def backupTickfiles(fname1):
f2 = []
f1 = []
fname2 = fname1.replace('.csv', 'bu.csv')
if os.path.isfile(fname2):
f2 = rpu_rp.CsvToLines(fname2)
if os.path.isfile(fname1):
f1 = rpu_rp.CsvToLines(fname1)
for line in f1:
f2.append(line)
rpu_rp.WriteArrayToCsvfile(fname2, f2)
def RTBar_reply_handler(msg):
if msg.typeName == 'realtimeBar':
reqid=(((str(msg)).split()[1]).split('=')[1]).replace(',','')
sym=symTickerIddict[reqid]
onerow = (str(msg)).split(',')
cleanonerow = TicksUtile.clean_RTTick5secBars(onerow,sym)
rpu_rp.WriteArrayToCsvfileAppend(DataDown +today+'.'+sym+ '.RTticks.csv',[cleanonerow])
rpu_rp.WriteArrayToCsvfile(DataDown +today+'.'+sym+ '.RTtickslastquote.csv',[cleanonerow])
else:
print str(msg)
rpu_rp.WriteStringsToFileAppend(TMP +'replys.RTticks',str(msg))
def scan_for_fills():
openarray = []
fillNoProf = []
filledNProfSent = []
replys = rpu_rp.CsvToLines(
TMP +
'entryreplys') ## this reads the replies from the sigcreate login
for l in rpu_rp.CsvToLines(entrysSentFile):
if len(l) > 0:
print l, 'checking for this in entries with a status poll'
status = 'open'
listordid = l[0]
#poll for status
tws_conn.orderStatus(listordid)
sleep(1) ### give it time to read list
## filledstring = 'orderStatus orderId='+listordid +', ' status=Filled'
for rep in replys:
## CAPTURE FILL PRICE HERE AND USE INSTEAD OF ENTRYPRICE IN FILE
if len(rep) > 1 and rep[1] == ' status=Filled' and rep[
0] == '<orderStatus orderId=' + listordid:
print 'found a fill in entry orders', listordid
status = 'filled'
if len(rep) > 1 and rep[1] == ' status=Cancelled' and rep[
0] == '<orderStatus orderId=' + listordid:
## print 'found a fill in entry orders', listordid
status = 'cxld'
if status == 'filled':
fillNoProf.append(l)
pass
elif status == 'cxld':
## print 'was cxld, deleting from list',l
pass
else:
openarray.append(l)
## print 'is open still',l
rpu_rp.WriteArrayToCsvfile(entrysSentFile, openarray)
rpu_rp.WriteArrayToCsvfile(filledNoProfFile, fillNoProf)
def trimFile(fname1, linesleft):
c = 0
f2 = []
f1 = []
f3 = []
fname2 = fname1.replace('.csv', 'bu.csv')
print fname1
if os.path.isfile(fname2):
f2 = rpu_rp.CsvToLines(fname2)
if os.path.isfile(fname1):
f1 = rpu_rp.CsvToLines(fname1)
lengthf1 = len(f1)
topfile = lengthf1 - linesleft
print topfile, linesleft
for line in f1:
c += 1
if c < topfile:
f2.append(line)
else:
f3.append(line)
rpu_rp.WriteArrayToCsvfile(fname2, f2)
rpu_rp.WriteArrayToCsvfile(fname1, f3)
def send_prof_orders():
## enter proforders if any
profsneeded = rpu_rp.CsvToLines(filledNoProfFile)
profsplaced = []
profitticks = 3
stopticks = 14
profmult = 1
## print profsneeded
## print 'those were all the profs needed'
for entryorder in profsneeded:
## print entryorder, 'entryorder'
flipsign = int(1)
tside = 'BUY'
if entryorder[1] == 'BUY':
tside = 'SELL'
flipsign = int(-1)
tsize = int(entryorder[2])
sym = entryorder[3]
profitticks = int(profticksdict[sym])
print 'original signal order = ', entryorder
orderprice = float(entryorder[4])
decimalboost = float(dboostdict[sym])
onetick = float(tickdict[sym])
addamt = onetick * int(entrywiderdict[sym])
tranflag = False
profprice = orderprice - (profmult * profitticks * onetick *
flipsign) - (flipsign * addamt)
stopprice = orderprice + (stopticks * onetick * flipsign) + (flipsign *
addamt)
## print profprice,stopprice
profitorder = ibutiles.create_order('LMT', tsize, tside, profprice,
tranflag, profprice, profprice,
'profit')
stoporder = ibutiles.create_order('STP', tsize, tside, stopprice,
tranflag, stopprice, stopprice,
'stop')
order_id = get_orderid()
symcontract = ibutiles.create_ticksym(
23, sym) ## might need to vary this number at some point
tws_conn.placeOrder(order_id, symcontract, profitorder)
tws_conn.placeOrder(order_id + 1, symcontract, stoporder)
print 'placed a profit and stop order here '
print sym, tside, str(tsize), str(profprice), 'PROFITORDER', order_id
profsplaced.append(entryorder)
sleep(2)
rpu_rp.WriteArrayToCsvfileAppend(filledNProfSentFile, profsplaced)
rpu_rp.WriteArrayToCsvfile(filledNoProfFile, [])
def merge_bar_files(filerecent,fileddload,fileboth,cutoffmintime):
cutofftimeEpoch = last_bar_epoch(fileddload,'noround')
# last_bar_epoch(filename,roundformat)
recentlines = rpu_rp.CsvToLines(filerecent) ## usually dload
ddloadlines = rpu_rp.CsvToLines(fileddload) ## usually recent
ddloadlineslen = len(ddloadlines)
cleanrlines =[]
for rline in recentlines:
if len(rline) > 2:
bartime_epoch = convertTime(rline[1],'dashspace','timetoepoch')
## print bartime_epoch, rline[1], cutofftimeEpoch,cutoffmintime
if bartime_epoch > (cutofftimeEpoch + cutoffmintime) and len(rline) > 3:
ddloadlines.append(rline)
## print 'dloadfile premerge len = ',ddloadlineslen, 'recfile len = ',len(recentlines),'merged = ',len(ddloadlines)
rpu_rp.WriteArrayToCsvfile(fileboth,ddloadlines) ## bothfile outfile created here
def align_tickfile(cutofftime, tickfile):
tempfile = tickfile.replace('.csv', 'temp.csv')
tempout = 'bla'
bufile = tickfile.replace('.csv', 'bu.csv')
shutil.copyfile(tickfile, bufile)
rlines = rpu_rp.CsvToLines(tickfile)
cleanrlines = []
for rline in rlines:
bartime = rline[1]
bartime_epoch = int(
time.mktime(time.strptime(bartime, spaceYtime_format)))
if bartime_epoch > cutofftime:
cleanrlines.append(rline)
rpu_rp.WriteArrayToCsvfile(tempfile, cleanrlines)
shutil.copyfile(tempfile, tempout)
def rewrite_param_file(varToChange,newvarval):
paramlines = rpu_rp.CsvToLines(SignalCP)
arrayout =[]
for line in paramlines:
varstring = line[0]
arrayline =[]
varvalue = read_vars('varstring')
## print varstring,varToChange
if varstring == varToChange:
print 'found a change'
varvalue = newvarval
arrayline.append(varstring)
arrayline.append(varvalue)
arrayout.append(arrayline)
else:
arrayout.append(line)
rpu_rp.WriteArrayToCsvfile(SignalCP,arrayout)
