Example #1
0
def getStepRangeAlgDesires(algKey, alginfo, startStep, stopStep):
    buyList = []
    sellList = []
    desireDict = {}
    buyCue = alginfo.BuyCue
    sellCue = alginfo.SellCue
    buyStartKey = meTools.buildDesireKey(startStep, buyCue, 0)
    buyStopKey = meTools.buildDesireKey(stopStep, buyCue, 99)
    buyQuery = "Select * From desire Where CueKey = '%s' " % (buyCue)
    buyQuery += " AND __key__ >= Key('desire','%s') AND __key__ <= Key('desire','%s')" % (buyStartKey, buyStopKey)
    sellStartKey = meTools.buildDesireKey(startStep, sellCue, 0)
    sellStopKey = meTools.buildDesireKey(stopStep, sellCue, 99)
    sellQuery = "Select * From desire Where CueKey = '%s' " % (sellCue)
    sellQuery += " AND __key__ >= Key('desire','%s') AND __key__ <= Key('desire','%s')" % (sellStartKey, sellStopKey)
    buyList = meTools.cachepy.get(buyQuery)
    if buyList is None:
        buyList = memcache.get(buyQuery)
        if buyList is None:
            buyList = db.GqlQuery(buyQuery).fetch(4000)
            memcache.set(buyQuery, buyList)
        meTools.cachepy.set(buyQuery, buyList)
    sellList = meTools.cachepy.get(sellQuery)
    if sellList is None:
        sellList = memcache.get(sellQuery)
        if sellList is None:
            sellList = db.GqlQuery(sellQuery).fetch(4000)
            memcache.set(sellQuery, sellList)
        meTools.cachepy.set(sellQuery, sellList)

    if len(buyList) > len(sellList):
        # If there are more buys than sells, fill dict with buys first
        # Then overwrite with sells.  Else, do reverse.
        # If there is a buy and a sell for a given stock on a certain step,
        # the less frequent action will be given precedence.
        for buy in buyList:
            keyname = buy.key().name()
            keyname = keyname.replace("_" + buyCue + "_", "_" + algKey + "_")
            desireDict[keyname] = processDesires.convertDesireToDict(buy, 1, alginfo.TradeSize, alginfo.Cash)
        for sell in sellList:
            keyname = sell.key().name()
            keyname = keyname.replace("_" + sellCue + "_", "_" + algKey + "_")
            desireDict[keyname] = processDesires.convertDesireToDict(sell, -1, alginfo.TradeSize, alginfo.Cash)
    else:
        for sell in sellList:
            keyname = sell.key().name()
            keyname = keyname.replace("_" + sellCue + "_", "_" + algKey + "_")
            desireDict[keyname] = processDesires.convertDesireToDict(sell, -1, alginfo.TradeSize, alginfo.Cash)
        for buy in buyList:
            keyname = buy.key().name()
            keyname = keyname.replace("_" + buyCue + "_", "_" + algKey + "_")
            desireDict[keyname] = processDesires.convertDesireToDict(buy, 1, alginfo.TradeSize, alginfo.Cash)
    return desireDict
Example #2
0
def updateAlgStats(step,alphaAlg=1,omegaAlg=3540):
    algstats = getAlgStats(alphaAlg,omegaAlg)
    desires = getDesires(step,alphaAlg,omegaAlg)
    alglist = {}
    for alg in algstats:
        desireKey = meTools.buildDesireKey(step,alg)
        if desires[desireKey] is not None:
            tradeCash, PandL, position = mergePosition(eval(desires[desireKey].desire),eval(algstats[alg].Positions))
            cash = tradeCash + algstats[alg].Cash
            if cash > 0:
                cashdelta = eval(decompress(algstats[alg].CashDelta))  # Get CashDelta collection
                cashdelta.appendleft({'value': tradeCash,
                                      'PandL': PandL,
                                      'step':  step})
                # Must check len() before pop() since not padding cashdelta.
                if len(cashdelta) > 800:
                    cashdelta.pop()
                
                algstats[alg].Cash = cash
                algstats[alg].Positions = repr(position)
                algstats[alg].PandL = PandL
                algstats[alg].CashDelta = compress(repr(cashdelta),9)
                alglist[alg] = algstats[alg]
        else:
            pass
    meTools.memPut_multi(meSchema.algStats,alglist)
Example #3
0
def makeDesire(stckID,keyname,step):
    symbol = meTools.getStckSymbol(stckID)
    pricekey = str(stckID) + "_" + str(step)
    price = meTools.memGet(meSchema.stck,pricekey,priority=0).quote
    key_name = meTools.buildDesireKey(step,keyname,stckID)
    meDesire = meSchema.desire(key_name = key_name, CueKey = keyname, Symbol = symbol, Quote = price)
    return meDesire
Example #4
0
def getDesires(step,alphaAlg=1,omegaAlg=3540):
    keylist = []
    model = meSchema.desire
    for i in range(alphaAlg,omegaAlg+1):
        key_name = meTools.buildDesireKey(step, str(i))
        keylist.append(key_name)
    desires = meTools.memGet_multi(model,keylist)
    return desires
def doAlgSteps(algKey, startStep, stopStep, stats, stckIDs, MaxTrade = False):
    if len(stckIDs) == 1:
        accumulate = True
    else:
        accumulate = False
    alginfo = meTools.memGet(meSchema.meAlg, algKey)
 
    if MaxTrade:
        alginfo.Cash = alginfo.Cash + stats['PandL']
        alginfo.TradeSize = (0.94/len(stckIDs))
    desires = liveAlg.getStepRangeAlgDesires(algKey, alginfo, startStep, stopStep)
    buydelta = meTools.memGet(meSchema.tradeCue, alginfo.BuyCue).TimeDelta
    selldelta = meTools.memGet(meSchema.tradeCue, alginfo.SellCue).TimeDelta

    orderDesires = desires.keys()
    orderDesires.sort()

    for step in range(startStep, stopStep + 1):
        stopRange = 80
        if (step - startStep - 44)%stopRange == 0:
            stats = doStops(step, copy.deepcopy(stats), alginfo, stopRange)
        potentialDesires = [meTools.buildDesireKey(step, algKey, stckID) for stckID in stckIDs]  # must feed stckIDs into func?
        for key in potentialDesires:
            if key in orderDesires:
                currentDesire = eval(desires[key])
                for des in currentDesire:            # Eventually re-do desires[key] to be just dict with 'Symbol' 'Shares' keys.
                    buysell = cmp(currentDesire[des]['Shares'], 0)
                    Symbol = des
                tradeCash, PandL, position = princeFunc.mergePosition(eval(desires[key]), copy.deepcopy(stats['Positions']), step, accumulate)
                cash = tradeCash + copy.deepcopy(stats['Cash'])
                if buysell == -1:
                    timedelta = selldelta
                    lastTradeStep = stats['lastSell']
                elif buysell == 1:
                    timedelta = buydelta
                    lastTradeStep = stats['lastBuy']

                if cash > 0 and lastTradeStep <= step - timedelta:
                    if buysell == -1:
                        stats['lastSell'] = step
                    elif buysell == 1:
                        stats['lastBuy'] = step
                    stats['CashDelta'].appendleft({'Symbol' : Symbol,
                                                   'buysell' : buysell,
                                                   'value'   : tradeCash,
                                                   'PandL'   : PandL,
                                                   'step'    : step})

                    if len(stats['CashDelta']) > 800:
                        stats['CashDelta'].pop()
                    stats['Cash'] = cash
                    stats['PandL'] += PandL
                    stats['Positions'] = position
    return stats
Example #6
0
def getDesireQueryStr(startStep,stopStep):
    alpha = meTools.buildDesireKey(startStep,0,0)
    omega = meTools.buildDesireKey(stopStep,61,5)    # Technically, this value should now be 60 since there are only 60 tradeCues.
    model = 'desire'
    query = "Select * from %s Where __key__ > Key('%s','%s') AND __key__ < Key('%s','%s')" % (model,model,alpha,model,omega)
    return query