_indcol = dict()

def __new__(meta, name, bases, dct):

# Hack to support original method name for notify_order

if 'notify' in dct:

# rename 'notify' to 'notify_order'

dct['notify_order'] = dct.pop('notify')

if 'notify_operation' in dct:

# rename 'notify' to 'notify_order'

dct['notify_trade'] = dct.pop('notify_operation')

return super(MetaStrategy, meta).__new__(meta, name, bases, dct)

def __init__(cls, name, bases, dct):

'''

# Initialize the class

super(MetaStrategy, cls).__init__(name, bases, dct)

if not cls.aliased and \

name != 'Strategy' and not name.startswith('_'):

cls._indcol[name] = cls

def donew(cls, *args, **kwargs):

_obj, args, kwargs = super(MetaStrategy, cls).donew(*args, **kwargs)

# Find the owner and store it

_obj.env = _obj.cerebro = cerebro = findowner(_obj, bt.Cerebro)

_obj._id = cerebro._next_stid()

return _obj, args, kwargs

def dopreinit(cls, _obj, *args, **kwargs):

_obj, args, kwargs = \

super(MetaStrategy, cls).dopreinit(_obj, *args, **kwargs)

_obj.broker = _obj.env.broker

_obj._sizer = bt.sizers.FixedSize()

_obj._orders = list()

_obj._orderspending = list()

_obj._trades = collections.defaultdict(AutoDictList)

_obj._tradespending = list()

_obj.stats = _obj.observers = ItemCollection()

_obj.analyzers = ItemCollection()

_obj._alnames = collections.defaultdict(itertools.count)

_obj.writers = list()

_obj._slave_analyzers = list()

_obj._tradehistoryon = False

return _obj, args, kwargs

def dopostinit(cls, _obj, *args, **kwargs):

_obj, args, kwargs = \

super(MetaStrategy, cls).dopostinit(_obj, *args, **kwargs)

_obj._sizer.set(_obj, _obj.broker)

'''

_ltype = LineIterator.StratType

csv = True

_oldsync = False # update clock using old methodology : data 0

# keep the latest delivered data date in the line

lines = ('datetime',)

def qbuffer(self, savemem=0, replaying=False):

'''Enable the memory saving schemes. Possible values for ``savemem``:

if savemem < 0:

# Get any attribute which labels itself as Indicator

for ind in self._lineiterators[self.IndType]:

subsave = isinstance(ind, (LineSingle,))

if not subsave and savemem < -1:

subsave = not ind.plotinfo.plot

ind.qbuffer(savemem=subsave)

elif savemem > 0:

for data in self.datas:

data.qbuffer(replaying=replaying)

for line in self.lines:

line.qbuffer(savemem=1)

# Save in all object types depending on the strategy

for itcls in self._lineiterators:

for it in self._lineiterators[itcls]:

it.qbuffer(savemem=1)

def _periodset(self):

dataids = [id(data) for data in self.datas]

_dminperiods = collections.defaultdict(list)

for lineiter in self._lineiterators[LineIterator.IndType]:

# if multiple datas are used and multiple timeframes the larger

# timeframe may place larger time constraints in calling next.

clk = getattr(lineiter, '_clock', None)

if clk is None:

clk = getattr(lineiter._owner, '_clock', None)

if clk is None:

continue

while True:

if id(clk) in dataids:

break # already top-level clock (data feed)

# See if the current clock has higher level clocks

clk2 = getattr(clk, '_clock', None)

if clk2 is None:

clk2 = getattr(clk._owner, '_clock', None)

if clk2 is None:

break # if no clock found, bail out

clk = clk2 # keep the ref and try to go up the hierarchy

if clk is None:

continue # no clock found, go to next

# LineSeriesStup wraps a line and the clock is the wrapped line and

# no the wrapper itself.

if isinstance(clk, LineSeriesStub):

clk = clk.lines[0]

_dminperiods[clk].append(lineiter._minperiod)

self._minperiods = list()

for data in self.datas:

# Do not only consider the data as clock but also its lines which

# may have been individually passed as clock references and

# discovered as clocks above

# Initialize with data min period if any

dlminperiods = _dminperiods[data]

for l in data.lines: # search each line for min periods

if l in _dminperiods:

dlminperiods += _dminperiods[l] # found, add it

# keep the reference to the line if any was found

_dminperiods[data] = [max(dlminperiods)] if dlminperiods else []

dminperiod = max(_dminperiods[data] or [data._minperiod])

self._minperiods.append(dminperiod)

# Set the minperiod

minperiods = \

[x._minperiod for x in self._lineiterators[LineIterator.IndType]]

self._minperiod = max(minperiods or [self._minperiod])

def _addwriter(self, writer):

'''

self.writers.append(writer)

def _addindicator(self, indcls, *indargs, **indkwargs):

indcls(*indargs, **indkwargs)

def _addanalyzer_slave(self, ancls, *anargs, **ankwargs):

'''Like _addanalyzer but meant for observers (or other entities) which

analyzer = ancls(*anargs, **ankwargs)

self._slave_analyzers.append(analyzer)

return analyzer

def _getanalyzer_slave(self, idx):

return self._slave_analyzers.append[idx]

def _addanalyzer(self, ancls, *anargs, **ankwargs):

anname = ankwargs.pop('_name', '') or ancls.__name__.lower()

nsuffix = next(self._alnames[anname])

anname += str(nsuffix or '') # 0 (first instance) gets no suffix

analyzer = ancls(*anargs, **ankwargs)

self.analyzers.append(analyzer, anname)

def _addobserver(self, multi, obscls, *obsargs, **obskwargs):

obsname = obskwargs.pop('obsname', '')

if not obsname:

obsname = obscls.__name__.lower()

if not multi:

newargs = list(itertools.chain(self.datas, obsargs))

obs = obscls(*newargs, **obskwargs)

self.stats.append(obs, obsname)

return

setattr(self.stats, obsname, list())

l = getattr(self.stats, obsname)

for data in self.datas:

obs = obscls(data, *obsargs, **obskwargs)

l.append(obs)

def _getminperstatus(self):

# check the min period status connected to datas

dlens = map(operator.sub, self._minperiods, map(len, self.datas))

self._minperstatus = minperstatus = max(dlens)

return minperstatus

def prenext_open(self):

pass

def nextstart_open(self):

self.next_open()

def next_open(self):

pass

def _oncepost_open(self):

minperstatus = self._minperstatus

if minperstatus < 0:

self.next_open()

elif minperstatus == 0:

self.nextstart_open() # only called for the 1st value

else:

self.prenext_open()

def _oncepost(self, dt):

for indicator in self._lineiterators[LineIterator.IndType]:

if len(indicator._clock) > len(indicator):

indicator.advance()

if self._oldsync:

# Strategy has not been reset, the line is there

self.advance()

else:

# strategy has been reset to beginning. advance step by step

self.forward()

self.lines.datetime[0] = dt

self._notify()

minperstatus = self._getminperstatus()

if minperstatus < 0:

self.next()

elif minperstatus == 0:

self.nextstart() # only called for the 1st value

else:

self.prenext()

self._next_analyzers(minperstatus, once=True)

self._next_observers(minperstatus, once=True)

self.clear()

def _clk_update(self):

if self._oldsync:

clk_len = super(Strategy, self)._clk_update()

self.lines.datetime[0] = max(d.datetime[0]

for d in self.datas if len(d))

return clk_len

newdlens = [len(d) for d in self.datas]

if any(nl > l for l, nl in zip(self._dlens, newdlens)):

self.forward()

self.lines.datetime[0] = max(d.datetime[0]

for d in self.datas if len(d))

self._dlens = newdlens

return len(self)

def _next_open(self):

minperstatus = self._minperstatus

if minperstatus < 0:

self.next_open()

elif minperstatus == 0:

self.nextstart_open() # only called for the 1st value

else:

self.prenext_open()

def _next(self):

super(Strategy, self)._next()

minperstatus = self._getminperstatus()

self._next_analyzers(minperstatus)

self._next_observers(minperstatus)

self.clear()

def _next_observers(self, minperstatus, once=False):

for observer in self._lineiterators[LineIterator.ObsType]:

for analyzer in observer._analyzers:

if minperstatus < 0:

analyzer._next()

elif minperstatus == 0:

analyzer._nextstart() # only called for the 1st value

else:

analyzer._prenext()

if once:

if len(self) > len(observer):

if self._oldsync:

observer.advance()

else:

observer.forward()

if minperstatus < 0:

observer.next()

elif minperstatus == 0:

observer.nextstart() # only called for the 1st value

elif len(observer):

observer.prenext()

else:

observer._next()

def _next_analyzers(self, minperstatus, once=False):

for analyzer in self.analyzers:

if minperstatus < 0:

analyzer._next()

elif minperstatus == 0:

analyzer._nextstart() # only called for the 1st value

else:

analyzer._prenext()

def _settz(self, tz):

self.lines.datetime._settz(tz)

def _start(self):

self._periodset()

for analyzer in itertools.chain(self.analyzers, self._slave_analyzers):

analyzer._start()

for obs in self.observers:

if not isinstance(obs, list):

obs = [obs] # support of multi-data observers

for o in obs:

o._start()

# change operators to stage 2

self._stage2()

self._dlens = [len(data) for data in self.datas]

self._minperstatus = MAXINT # start in prenext

self.start()

def start(self):

'''Called right before the backtesting is about to be started.'''

pass

def getwriterheaders(self):

self.indobscsv = [self]

indobs = itertools.chain(

self.getindicators_lines(), self.getobservers())

self.indobscsv.extend(filter(lambda x: x.csv, indobs))

headers = list()

# prepare the indicators/observers data headers

for iocsv in self.indobscsv:

name = iocsv.plotinfo.plotname or iocsv.__class__.__name__

headers.append(name)

headers.append('len')

headers.extend(iocsv.getlinealiases())

return headers

def getwritervalues(self):

values = list()

for iocsv in self.indobscsv:

name = iocsv.plotinfo.plotname or iocsv.__class__.__name__

values.append(name)

lio = len(iocsv)

values.append(lio)

if lio:

values.extend(map(lambda l: l[0], iocsv.lines.itersize()))

else:

values.extend([''] * iocsv.lines.size())

return values

def getwriterinfo(self):

wrinfo = AutoOrderedDict()

wrinfo['Params'] = self.p._getkwargs()

sections = [

['Indicators', self.getindicators_lines()],

['Observers', self.getobservers()]

]

for sectname, sectitems in sections:

sinfo = wrinfo[sectname]

for item in sectitems:

itname = item.__class__.__name__

sinfo[itname].Lines = item.lines.getlinealiases() or None

sinfo[itname].Params = item.p._getkwargs() or None

ainfo = wrinfo.Analyzers

# Internal Value Analyzer

ainfo.Value.Begin = self.broker.startingcash

ainfo.Value.End = self.broker.getvalue()

# no slave analyzers for writer

for aname, analyzer in self.analyzers.getitems():

ainfo[aname].Params = analyzer.p._getkwargs() or None

ainfo[aname].Analysis = analyzer.get_analysis()

return wrinfo

def _stop(self):

self.stop()

for analyzer in itertools.chain(self.analyzers, self._slave_analyzers):

analyzer._stop()

# change operators back to stage 1 - allows reuse of datas

self._stage1()

def stop(self):

'''Called right before the backtesting is about to be stopped'''

pass

def set_tradehistory(self, onoff=True):

self._tradehistoryon = onoff

def clear(self):

self._orders.extend(self._orderspending)

self._orderspending = list()

self._tradespending = list()

def _addnotification(self, order, quicknotify=False):

if not order.p.simulated:

self._orderspending.append(order)

if quicknotify:

qorders = [order]

qtrades = []

if not order.executed.size:

if quicknotify:

self._notify(qorders=qorders, qtrades=qtrades)

return

tradedata = order.data._compensate

if tradedata is None:

tradedata = order.data

datatrades = self._trades[tradedata][order.tradeid]

if not datatrades:

trade = Trade(data=tradedata, tradeid=order.tradeid,

historyon=self._tradehistoryon)

datatrades.append(trade)

else:

trade = datatrades[-1]

for exbit in order.executed.iterpending():

if exbit is None:

break

if exbit.closed:

trade.update(order,

exbit.closed,

exbit.price,

exbit.closedvalue,

exbit.closedcomm,

exbit.pnl,

comminfo=order.comminfo)

if trade.isclosed:

self._tradespending.append(copy.copy(trade))

if quicknotify:

qtrades.append(copy.copy(trade))

# Update it if needed

if exbit.opened:

if trade.isclosed:

trade = Trade(data=tradedata, tradeid=order.tradeid,

historyon=self._tradehistoryon)

datatrades.append(trade)

trade.update(order,

exbit.opened,

exbit.price,

exbit.openedvalue,

exbit.openedcomm,

exbit.pnl,

comminfo=order.comminfo)

# This extra check covers the case in which different tradeid

# orders have put the position down to 0 and the next order

# "opens" a position but "closes" the trade

if trade.isclosed:

self._tradespending.append(copy.copy(trade))

if quicknotify:

qtrades.append(copy.copy(trade))

if trade.justopened:

self._tradespending.append(copy.copy(trade))

if quicknotify:

qtrades.append(copy.copy(trade))

if quicknotify:

self._notify(qorders=qorders, qtrades=qtrades)

def _notify(self, qorders=[], qtrades=[]):

if self.cerebro.p.quicknotify:

# need to know if quicknotify is on, to not reprocess pendingorders

# and pendingtrades, which have to exist for things like observers

# which look into it

procorders = qorders

proctrades = qtrades

else:

procorders = self._orderspending

proctrades = self._tradespending

for order in procorders:

if order.exectype != order.Historical or order.histnotify:

self.notify_order(order)

for analyzer in itertools.chain(self.analyzers,

self._slave_analyzers):

analyzer._notify_order(order)

for trade in proctrades:

self.notify_trade(trade)

for analyzer in itertools.chain(self.analyzers,

self._slave_analyzers):

analyzer._notify_trade(trade)

if qorders:

return # cash is notified on a regular basis

cash = self.broker.getcash()

value = self.broker.getvalue()

fundvalue = self.broker.fundvalue

fundshares = self.broker.fundshares

self.notify_cashvalue(cash, value)

self.notify_fund(cash, value, fundvalue, fundshares)

for analyzer in itertools.chain(self.analyzers, self._slave_analyzers):

analyzer._notify_cashvalue(cash, value)

analyzer._notify_fund(cash, value, fundvalue, fundshares)

def add_timer(self, when,

offset=datetime.timedelta(), repeat=datetime.timedelta(),

weekdays=[], weekcarry=False,

monthdays=[], monthcarry=True,

allow=None,

tzdata=None, cheat=False,

*args, **kwargs):

'''

return self.cerebro._add_timer(

owner=self, when=when, offset=offset, repeat=repeat,

weekdays=weekdays, weekcarry=weekcarry,

monthdays=monthdays, monthcarry=monthcarry,

allow=allow,

tzdata=tzdata, strats=False, cheat=cheat,

*args, **kwargs)

def notify_timer(self, timer, when, *args, **kwargs):

'''Receives a timer notification where ``timer`` is the timer which was

pass

def notify_cashvalue(self, cash, value):

'''

pass

def notify_fund(self, cash, value, fundvalue, shares):

'''

pass

def notify_order(self, order):

'''

pass

def notify_trade(self, trade):

'''

pass

def notify_store(self, msg, *args, **kwargs):

'''Receives a notification from a store provider'''

pass

def notify_data(self, data, status, *args, **kwargs):

'''Receives a notification from data'''

pass

def getdatanames(self):

'''

return keys(self.env.datasbyname)

def getdatabyname(self, name):

'''

return self.env.datasbyname[name]

def cancel(self, order):

'''Cancels the order in the broker'''

self.broker.cancel(order)

def buy(self, data=None,

size=None, price=None, plimit=None,

exectype=None, valid=None, tradeid=0, oco=None,

trailamount=None, trailpercent=None,

parent=None, transmit=True,

**kwargs):

'''Create a buy (long) order and send it to the broker

if isinstance(data, string_types):

data = self.getdatabyname(data)

data = data if data is not None else self.datas[0]

size = size if size is not None else self.getsizing(data, isbuy=True)

if size:

return self.broker.buy(

self, data,

size=abs(size), price=price, plimit=plimit,

exectype=exectype, valid=valid, tradeid=tradeid, oco=oco,

trailamount=trailamount, trailpercent=trailpercent,

parent=parent, transmit=transmit,

**kwargs)

return None

def sell(self, data=None,

size=None, price=None, plimit=None,

exectype=None, valid=None, tradeid=0, oco=None,

trailamount=None, trailpercent=None,

parent=None, transmit=True,

**kwargs):

'''

if isinstance(data, string_types):

data = self.getdatabyname(data)

data = data if data is not None else self.datas[0]

size = size if size is not None else self.getsizing(data, isbuy=False)

if size:

return self.broker.sell(

self, data,

size=abs(size), price=price, plimit=plimit,

exectype=exectype, valid=valid, tradeid=tradeid, oco=oco,

trailamount=trailamount, trailpercent=trailpercent,

parent=parent, transmit=transmit,

**kwargs)

return None

def close(self, data=None, size=None, **kwargs):

'''

if isinstance(data, string_types):

data = self.getdatabyname(data)

elif data is None:

data = self.data

possize = self.getposition(data, self.broker).size

size = abs(size if size is not None else possize)

if possize > 0:

return self.sell(data=data, size=size, **kwargs)

elif possize < 0:

return self.buy(data=data, size=size, **kwargs)

return None