SYMBOL INDEX (2596 symbols across 323 files)

FILE: backtrader/analyzer.py
  class MetaAnalyzer (line 34) | class MetaAnalyzer(bt.MetaParams):
    method donew (line 35) | def donew(cls, *args, **kwargs):
    method dopostinit (line 78) | def dopostinit(cls, _obj, *args, **kwargs):
  class Analyzer (line 89) | class Analyzer(with_metaclass(MetaAnalyzer, object)):
    method __len__ (line 140) | def __len__(self):
    method _register (line 145) | def _register(self, child):
    method _prenext (line 148) | def _prenext(self):
    method _notify_cashvalue (line 154) | def _notify_cashvalue(self, cash, value):
    method _notify_fund (line 160) | def _notify_fund(self, cash, value, fundvalue, shares):
    method _notify_trade (line 166) | def _notify_trade(self, trade):
    method _notify_order (line 172) | def _notify_order(self, order):
    method _nextstart (line 178) | def _nextstart(self):
    method _next (line 184) | def _next(self):
    method _start (line 190) | def _start(self):
    method _stop (line 196) | def _stop(self):
    method notify_cashvalue (line 202) | def notify_cashvalue(self, cash, value):
    method notify_fund (line 206) | def notify_fund(self, cash, value, fundvalue, shares):
    method notify_order (line 210) | def notify_order(self, order):
    method notify_trade (line 214) | def notify_trade(self, trade):
    method next (line 218) | def next(self):
    method prenext (line 223) | def prenext(self):
    method nextstart (line 231) | def nextstart(self):
    method start (line 237) | def start(self):
    method stop (line 242) | def stop(self):
    method create_analysis (line 247) | def create_analysis(self):
    method get_analysis (line 255) | def get_analysis(self):
    method print (line 270) | def print(self, *args, **kwargs):
    method pprint (line 282) | def pprint(self, *args, **kwargs):
  class MetaTimeFrameAnalyzerBase (line 289) | class MetaTimeFrameAnalyzerBase(Analyzer.__class__):
    method __new__ (line 290) | def __new__(meta, name, bases, dct):
  class TimeFrameAnalyzerBase (line 299) | class TimeFrameAnalyzerBase(with_metaclass(MetaTimeFrameAnalyzerBase,
    method _start (line 307) | def _start(self):
    method _prenext (line 315) | def _prenext(self):
    method _nextstart (line 325) | def _nextstart(self):
    method _next (line 334) | def _next(self):
    method on_dt_over (line 343) | def on_dt_over(self):
    method _dt_over (line 346) | def _dt_over(self):
    method _get_dt_cmpkey (line 361) | def _get_dt_cmpkey(self, dt):
    method _get_subday_cmpkey (line 389) | def _get_subday_cmpkey(self, dt):

FILE: backtrader/analyzers/annualreturn.py
  class AnnualReturn (line 30) | class AnnualReturn(Analyzer):
    method stop (line 50) | def stop(self):
    method get_analysis (line 88) | def get_analysis(self):

FILE: backtrader/analyzers/calmar.py
  class Calmar (line 31) | class Calmar(bt.TimeFrameAnalyzerBase):
    method __init__ (line 83) | def __init__(self):
    method start (line 87) | def start(self):
    method on_dt_over (line 101) | def on_dt_over(self):
    method stop (line 112) | def stop(self):

FILE: backtrader/analyzers/drawdown.py
  class DrawDown (line 31) | class DrawDown(bt.Analyzer):
    method start (line 67) | def start(self):
    method create_analysis (line 74) | def create_analysis(self):
    method stop (line 87) | def stop(self):
    method notify_fund (line 90) | def notify_fund(self, cash, value, fundvalue, shares):
    method next (line 98) | def next(self):
  class TimeDrawDown (line 113) | class TimeDrawDown(bt.TimeFrameAnalyzerBase):
    method start (line 164) | def start(self):
    method on_dt_over (line 176) | def on_dt_over(self):
    method stop (line 195) | def stop(self):

FILE: backtrader/analyzers/leverage.py
  class GrossLeverage (line 27) | class GrossLeverage(bt.Analyzer):
    method start (line 54) | def start(self):
    method notify_fund (line 60) | def notify_fund(self, cash, value, fundvalue, shares):
    method next (line 67) | def next(self):

FILE: backtrader/analyzers/logreturnsrolling.py
  class LogReturnsRolling (line 33) | class LogReturnsRolling(bt.TimeFrameAnalyzerBase):
    method start (line 102) | def start(self):
    method notify_fund (line 119) | def notify_fund(self, cash, value, fundvalue, shares):
    method _on_dt_over (line 125) | def _on_dt_over(self):
    method next (line 136) | def next(self):

FILE: backtrader/analyzers/periodstats.py
  class PeriodStats (line 34) | class PeriodStats(bt.Analyzer):
    method __init__ (line 85) | def __init__(self):
    method stop (line 89) | def stop(self):

FILE: backtrader/analyzers/positions.py
  class PositionsValue (line 28) | class PositionsValue(bt.Analyzer):
    method start (line 68) | def start(self):
    method next (line 77) | def next(self):

FILE: backtrader/analyzers/pyfolio.py
  class PyFolio (line 33) | class PyFolio(bt.Analyzer):
    method __init__ (line 86) | def __init__(self):
    method stop (line 95) | def stop(self):
    method get_pf_items (line 102) | def get_pf_items(self):

FILE: backtrader/analyzers/returns.py
  class Returns (line 30) | class Returns(TimeFrameAnalyzerBase):
    method start (line 104) | def start(self):
    method stop (line 118) | def stop(self):
    method _on_dt_over (line 154) | def _on_dt_over(self):

FILE: backtrader/analyzers/sharpe.py
  class SharpeRatio (line 33) | class SharpeRatio(Analyzer):
    method __init__ (line 134) | def __init__(self):
    method stop (line 143) | def stop(self):
  class SharpeRatio_A (line 209) | class SharpeRatio_A(SharpeRatio):

FILE: backtrader/analyzers/sqn.py
  class SQN (line 31) | class SQN(Analyzer):
    method create_analysis (line 58) | def create_analysis(self):
    method start (line 63) | def start(self):
    method notify_trade (line 68) | def notify_trade(self, trade):
    method stop (line 73) | def stop(self):

FILE: backtrader/analyzers/timereturn.py
  class TimeReturn (line 27) | class TimeReturn(TimeFrameAnalyzerBase):
    method start (line 96) | def start(self):
    method notify_fund (line 112) | def notify_fund(self, cash, value, fundvalue, shares):
    method on_dt_over (line 125) | def on_dt_over(self):
    method next (line 138) | def next(self):

FILE: backtrader/analyzers/tradeanalyzer.py
  class TradeAnalyzer (line 31) | class TradeAnalyzer(Analyzer):
    method create_analysis (line 68) | def create_analysis(self):
    method stop (line 72) | def stop(self):
    method notify_trade (line 76) | def notify_trade(self, trade):

FILE: backtrader/analyzers/transactions.py
  class Transactions (line 31) | class Transactions(bt.Analyzer):
    method start (line 65) | def start(self):
    method notify_order (line 73) | def notify_order(self, order):
    method next (line 90) | def next(self):

FILE: backtrader/analyzers/vwr.py
  class VWR (line 32) | class VWR(TimeFrameAnalyzerBase):
    method __init__ (line 114) | def __init__(self):
    method start (line 120) | def start(self):
    method stop (line 135) | def stop(self):
    method notify_fund (line 162) | def notify_fund(self, cash, value, fundvalue, shares):
    method _on_dt_over (line 168) | def _on_dt_over(self):

FILE: backtrader/broker.py
  class MetaBroker (line 32) | class MetaBroker(MetaParams):
    method __init__ (line 33) | def __init__(cls, name, bases, dct):
  class BrokerBase (line 49) | class BrokerBase(with_metaclass(MetaBroker, object)):
    method __init__ (line 54) | def __init__(self):
    method init (line 58) | def init(self):
    method start (line 63) | def start(self):
    method stop (line 66) | def stop(self):
    method add_order_history (line 69) | def add_order_history(self, orders, notify=False):
    method set_fund_history (line 73) | def set_fund_history(self, fund):
    method getcommissioninfo (line 77) | def getcommissioninfo(self, data):
    method setcommission (line 85) | def setcommission(self,
    method addcommissioninfo (line 107) | def addcommissioninfo(self, comminfo, name=None):
    method getcash (line 112) | def getcash(self):
    method getvalue (line 115) | def getvalue(self, datas=None):
    method get_fundshares (line 118) | def get_fundshares(self):
    method get_fundvalue (line 124) | def get_fundvalue(self):
    method set_fundmode (line 129) | def set_fundmode(self, fundmode, fundstartval=None):
    method get_fundmode (line 136) | def get_fundmode(self):
    method getposition (line 142) | def getposition(self, data):
    method submit (line 145) | def submit(self, order):
    method cancel (line 148) | def cancel(self, order):
    method buy (line 151) | def buy(self, owner, data, size, price=None, plimit=None,
    method sell (line 158) | def sell(self, owner, data, size, price=None, plimit=None,
    method next (line 165) | def next(self):

FILE: backtrader/brokers/bbroker.py
  class BackBroker (line 36) | class BackBroker(bt.BrokerBase):
    method __init__ (line 244) | def __init__(self):
    method init (line 251) | def init(self):
    method get_notification (line 283) | def get_notification(self):
    method set_fundmode (line 291) | def set_fundmode(self, fundmode, fundstartval=None):
    method get_fundmode (line 300) | def get_fundmode(self):
    method set_fundstartval (line 306) | def set_fundstartval(self, fundstartval):
    method set_int2pnl (line 310) | def set_int2pnl(self, int2pnl):
    method set_coc (line 314) | def set_coc(self, coc):
    method set_coo (line 318) | def set_coo(self, coo):
    method set_shortcash (line 322) | def set_shortcash(self, shortcash):
    method set_slippage_perc (line 326) | def set_slippage_perc(self, perc,
    method set_slippage_fixed (line 337) | def set_slippage_fixed(self, fixed,
    method set_filler (line 348) | def set_filler(self, filler):
    method set_checksubmit (line 352) | def set_checksubmit(self, checksubmit):
    method set_eosbar (line 356) | def set_eosbar(self, eosbar):
    method get_cash (line 362) | def get_cash(self):
    method set_cash (line 368) | def set_cash(self, cash):
    method add_cash (line 375) | def add_cash(self, cash):
    method get_fundshares (line 379) | def get_fundshares(self):
    method get_fundvalue (line 385) | def get_fundvalue(self):
    method cancel (line 391) | def cancel(self, order, bracket=False):
    method get_value (line 405) | def get_value(self, datas=None, mkt=False, lever=False):
    method get_value_lever (line 419) | def get_value_lever(self, datas=None, mkt=False):
    method _get_value (line 422) | def _get_value(self, datas=None, lever=False):
    method get_leverage (line 489) | def get_leverage(self):
    method get_orders_open (line 492) | def get_orders_open(self, safe=False):
    method getposition (line 507) | def getposition(self, data):
    method orderstatus (line 512) | def orderstatus(self, order):
    method _take_children (line 520) | def _take_children(self, order):
    method submit (line 532) | def submit(self, order, check=True):
    method transmit (line 547) | def transmit(self, order, check=True):
    method check_submitted (line 558) | def check_submitted(self):
    method submit_accept (line 585) | def submit_accept(self, order):
    method _bracketize (line 592) | def _bracketize(self, order, cancel=False):
    method _ococheck (line 609) | def _ococheck(self, order):
    method _ocoize (line 622) | def _ocoize(self, order, oco):
    method add_order_history (line 632) | def add_order_history(self, orders, notify=True):
    method set_fund_history (line 637) | def set_fund_history(self, fund):
    method buy (line 647) | def buy(self, owner, data,
    method sell (line 667) | def sell(self, owner, data,
    method _execute (line 687) | def _execute(self, order, ago=None, price=None, cash=None, position=None,
    method notify (line 847) | def notify(self, order):
    method _try_exec_historical (line 850) | def _try_exec_historical(self, order):
    method _try_exec_market (line 853) | def _try_exec_market(self, order, popen, phigh, plow):
    method _try_exec_close (line 872) | def _try_exec_close(self, order, pclose):
    method _try_exec_limit (line 898) | def _try_exec_limit(self, order, popen, phigh, plow, plimit):
    method _try_exec_stop (line 921) | def _try_exec_stop(self, order, popen, phigh, plow, pcreated, pclose):
    method _try_exec_stoplimit (line 946) | def _try_exec_stoplimit(self, order,
    method _slip_up (line 994) | def _slip_up(self, pmax, price, doslip=True, lim=False):
    method _slip_down (line 1017) | def _slip_down(self, pmin, price, doslip=True, lim=False):
    method _try_exec (line 1040) | def _try_exec(self, order):
    method _process_fund_history (line 1083) | def _process_fund_history(self):
    method _process_order_history (line 1116) | def _process_order_history(self):
    method next (line 1176) | def next(self):

FILE: backtrader/brokers/ibbroker.py
  class IBOrderState (line 47) | class IBOrderState(object):
    method __init__ (line 53) | def __init__(self, orderstate):
    method __str__ (line 58) | def __str__(self):
  class IBOrder (line 68) | class IBOrder(OrderBase, ib.ext.Order.Order):
    method __str__ (line 93) | def __str__(self):
    method __init__ (line 121) | def __init__(self, action, **kwargs):
  class IBCommInfo (line 208) | class IBCommInfo(CommInfoBase):
    method getvaluesize (line 222) | def getvaluesize(self, size, price):
    method getoperationcost (line 226) | def getoperationcost(self, size, price):
  class MetaIBBroker (line 232) | class MetaIBBroker(BrokerBase.__class__):
    method __init__ (line 233) | def __init__(cls, name, bases, dct):
  class IBBroker (line 240) | class IBBroker(with_metaclass(MetaIBBroker, BrokerBase)):
    method __init__ (line 265) | def __init__(self, **kwargs):
    method start (line 280) | def start(self):
    method stop (line 292) | def stop(self):
    method getcash (line 296) | def getcash(self):
    method getvalue (line 301) | def getvalue(self, datas=None):
    method getposition (line 305) | def getposition(self, data, clone=True):
    method cancel (line 308) | def cancel(self, order):
    method orderstatus (line 319) | def orderstatus(self, order):
    method submit (line 327) | def submit(self, order):
    method getcommissioninfo (line 342) | def getcommissioninfo(self, data):
    method _makeorder (line 353) | def _makeorder(self, action, owner, data,
    method buy (line 369) | def buy(self, owner, data,
    method sell (line 381) | def sell(self, owner, data,
    method notify (line 393) | def notify(self, order):
    method get_notification (line 396) | def get_notification(self):
    method next (line 404) | def next(self):
    method push_orderstatus (line 413) | def push_orderstatus(self, msg):
    method push_execution (line 477) | def push_execution(self, ex):
    method push_commissionreport (line 480) | def push_commissionreport(self, cr):
    method push_portupdate (line 532) | def push_portupdate(self):
    method push_ordererror (line 543) | def push_ordererror(self, msg):
    method push_orderstate (line 565) | def push_orderstate(self, msg):

FILE: backtrader/brokers/oandabroker.py
  class OandaCommInfo (line 41) | class OandaCommInfo(CommInfoBase):
    method getvaluesize (line 42) | def getvaluesize(self, size, price):
    method getoperationcost (line 46) | def getoperationcost(self, size, price):
  class MetaOandaBroker (line 52) | class MetaOandaBroker(BrokerBase.__class__):
    method __init__ (line 53) | def __init__(cls, name, bases, dct):
  class OandaBroker (line 60) | class OandaBroker(with_metaclass(MetaOandaBroker, BrokerBase)):
    method __init__ (line 79) | def __init__(self, **kwargs):
    method start (line 94) | def start(self):
    method data_started (line 110) | def data_started(self, data):
    method stop (line 145) | def stop(self):
    method getcash (line 149) | def getcash(self):
    method getvalue (line 154) | def getvalue(self, datas=None):
    method getposition (line 158) | def getposition(self, data, clone=True):
    method orderstatus (line 166) | def orderstatus(self, order):
    method _submit (line 170) | def _submit(self, oref):
    method _reject (line 178) | def _reject(self, oref):
    method _accept (line 184) | def _accept(self, oref):
    method _cancel (line 192) | def _cancel(self, oref):
    method _expire (line 198) | def _expire(self, oref):
    method _bracketnotif (line 204) | def _bracketnotif(self, order):
    method _bracketize (line 209) | def _bracketize(self, order, cancel=False):
    method _fill (line 231) | def _fill(self, oref, size, price, ttype, **kwargs):
    method _transmit (line 281) | def _transmit(self, order):
    method buy (line 306) | def buy(self, owner, data,
    method sell (line 323) | def sell(self, owner, data,
    method cancel (line 340) | def cancel(self, order):
    method notify (line 347) | def notify(self, order):
    method get_notification (line 350) | def get_notification(self):
    method next (line 356) | def next(self):

FILE: backtrader/brokers/vcbroker.py
  class VCCommInfo (line 38) | class VCCommInfo(CommInfoBase):
    method getvaluesize (line 52) | def getvaluesize(self, size, price):
    method getoperationcost (line 56) | def getoperationcost(self, size, price):
  class MetaVCBroker (line 62) | class MetaVCBroker(BrokerBase.__class__):
    method __init__ (line 63) | def __init__(cls, name, bases, dct):
  class VCBroker (line 70) | class VCBroker(with_metaclass(MetaVCBroker, BrokerBase)):
    method __init__ (line 131) | def __init__(self, **kwargs):
    method start (line 182) | def start(self):
    method stop (line 186) | def stop(self):
    method getcash (line 190) | def getcash(self):
    method getvalue (line 194) | def getvalue(self, datas=None):
    method get_notification (line 197) | def get_notification(self):
    method notify (line 200) | def notify(self, order):
    method next (line 203) | def next(self):
    method getposition (line 206) | def getposition(self, data, clone=True):
    method getcommissioninfo (line 214) | def getcommissioninfo(self, data):
    method _makeorder (line 226) | def _makeorder(self, ordtype, owner, data,
    method submit (line 291) | def submit(self, order, vcorder):
    method buy (line 310) | def buy(self, owner, data,
    method sell (line 327) | def sell(self, owner, data,
    method __call__ (line 347) | def __call__(self, trader):
    method OnChangedBalance (line 361) | def OnChangedBalance(self, Account):
    method OnModifiedOrder (line 372) | def OnModifiedOrder(self, Order):
    method OnCancelledOrder (line 377) | def OnCancelledOrder(self, Order):
    method OnTotalExecutedOrder (line 387) | def OnTotalExecutedOrder(self, Order):
    method OnPartialExecutedOrder (line 390) | def OnPartialExecutedOrder(self, Order):
    method OnExecutedOrder (line 393) | def OnExecutedOrder(self, Order, partial):
    method OnOrderInMarket (line 436) | def OnOrderInMarket(self, Order):
    method OnNewOrderLocation (line 447) | def OnNewOrderLocation(self, Order):
    method OnChangedOpenPositions (line 451) | def OnChangedOpenPositions(self, Account):
    method OnNewClosedOperations (line 458) | def OnNewClosedOperations(self, Account):
    method OnServerShutDown (line 462) | def OnServerShutDown(self):
    method OnInternalEvent (line 465) | def OnInternalEvent(self, p1, p2, p3):

FILE: backtrader/btrun/btrun.py
  function btrun (line 73) | def btrun(pargs=''):
  function setbroker (line 171) | def setbroker(args, cerebro):
  function getdatas (line 204) | def getdatas(args):
  function getmodclasses (line 245) | def getmodclasses(mod, clstype, clsname=None):
  function getmodfunctions (line 263) | def getmodfunctions(mod, funcname=None):
  function loadmodule (line 279) | def loadmodule(modpath, modname=''):
  function loadmodule2 (line 299) | def loadmodule2(modpath, modname):
  function loadmodule3 (line 310) | def loadmodule3(modpath, modname):
  function getobjects (line 322) | def getobjects(iterable, clsbase, modbase, issignal=False):
  function getfunctions (line 373) | def getfunctions(iterable, modbase):
  function parse_args (line 415) | def parse_args(pargs=''):

FILE: backtrader/cerebro.py
  class OptReturn (line 53) | class OptReturn(object):
    method __init__ (line 54) | def __init__(self, params, **kwargs):
  class Cerebro (line 60) | class Cerebro(with_metaclass(MetaParams, object)):
    method __init__ (line 296) | def __init__(self):
    method iterize (line 330) | def iterize(iterable):
    method set_fund_history (line 345) | def set_fund_history(self, fund):
    method add_order_history (line 369) | def add_order_history(self, orders, notify=True):
    method notify_timer (line 410) | def notify_timer(self, timer, when, *args, **kwargs):
    method _add_timer (line 421) | def _add_timer(self, owner, when,
    method add_timer (line 446) | def add_timer(self, when,
    method addtz (line 545) | def addtz(self, tz):
    method addcalendar (line 566) | def addcalendar(self, cal):
    method add_signal (line 592) | def add_signal(self, sigtype, sigcls, *sigargs, **sigkwargs):
    method signal_strategy (line 597) | def signal_strategy(self, stratcls, *args, **kwargs):
    method signal_concurrent (line 601) | def signal_concurrent(self, onoff):
    method signal_accumulate (line 606) | def signal_accumulate(self, onoff):
    method addstore (line 612) | def addstore(self, store):
    method addwriter (line 617) | def addwriter(self, wrtcls, *args, **kwargs):
    method addsizer (line 623) | def addsizer(self, sizercls, *args, **kwargs):
    method addsizer_byidx (line 629) | def addsizer_byidx(self, idx, sizercls, *args, **kwargs):
    method addindicator (line 636) | def addindicator(self, indcls, *args, **kwargs):
    method addanalyzer (line 643) | def addanalyzer(self, ancls, *args, **kwargs):
    method addobserver (line 650) | def addobserver(self, obscls, *args, **kwargs):
    method addobservermulti (line 657) | def addobservermulti(self, obscls, *args, **kwargs):
    method addstorecb (line 669) | def addstorecb(self, callback):
    method _notify_store (line 684) | def _notify_store(self, msg, *args, **kwargs):
    method notify_store (line 690) | def notify_store(self, msg, *args, **kwargs):
    method _storenotify (line 702) | def _storenotify(self):
    method adddatacb (line 711) | def adddatacb(self, callback):
    method _datanotify (line 726) | def _datanotify(self):
    method _notify_data (line 734) | def _notify_data(self, data, status, *args, **kwargs):
    method notify_data (line 740) | def notify_data(self, data, status, *args, **kwargs):
    method adddata (line 752) | def adddata(self, data, name=None):
    method chaindata (line 776) | def chaindata(self, *args, **kwargs):
    method rolloverdata (line 793) | def rolloverdata(self, *args, **kwargs):
    method replaydata (line 812) | def replaydata(self, dataname, name=None, **kwargs):
    method resampledata (line 831) | def resampledata(self, dataname, name=None, **kwargs):
    method optcallback (line 850) | def optcallback(self, cb):
    method optstrategy (line 859) | def optstrategy(self, strategy, *args, **kwargs):
    method addstrategy (line 908) | def addstrategy(self, strategy, *args, **kwargs):
    method setbroker (line 922) | def setbroker(self, broker):
    method getbroker (line 931) | def getbroker(self):
    method plot (line 941) | def plot(self, plotter=None, numfigs=1, iplot=True, start=None, end=None,
    method __call__ (line 1005) | def __call__(self, iterstrat):
    method __getstate__ (line 1014) | def __getstate__(self):
    method runstop (line 1025) | def runstop(self):
    method run (line 1030) | def run(self, **kwargs):
    method _init_stcount (line 1165) | def _init_stcount(self):
    method _next_stid (line 1168) | def _next_stid(self):
    method runstrategies (line 1171) | def runstrategies(self, iterstrat, predata=False):
    method stop_writers (line 1340) | def stop_writers(self, runstrats):
    method _brokernotify (line 1360) | def _brokernotify(self):
    method _runnext_old (line 1377) | def _runnext_old(self, runstrats):
    method _runonce_old (line 1443) | def _runonce_old(self, runstrats):
    method _next_writers (line 1475) | def _next_writers(self, runstrats):
    method _disable_runonce (line 1494) | def _disable_runonce(self):
    method _runnext (line 1498) | def _runnext(self, runstrats):
    method _runonce (line 1649) | def _runonce(self, runstrats):
    method _check_timers (line 1706) | def _check_timers(self, runstrats, dt0, cheat=False):

FILE: backtrader/comminfo.py
  class CommInfoBase (line 30) | class CommInfoBase(with_metaclass(MetaParams)):
    method __init__ (line 133) | def __init__(self):
    method margin (line 162) | def margin(self):
    method stocklike (line 166) | def stocklike(self):
    method get_margin (line 169) | def get_margin(self, price):
    method get_leverage (line 187) | def get_leverage(self):
    method getsize (line 192) | def getsize(self, price, cash):
    method getoperationcost (line 199) | def getoperationcost(self, size, price):
    method getvaluesize (line 206) | def getvaluesize(self, size, price):
    method getvalue (line 214) | def getvalue(self, position, price):
    method _getcommission (line 229) | def _getcommission(self, size, price, pseudoexec):
    method getcommission (line 239) | def getcommission(self, size, price):
    method confirmexec (line 244) | def confirmexec(self, size, price):
    method profitandloss (line 247) | def profitandloss(self, size, price, newprice):
    method cashadjust (line 251) | def cashadjust(self, size, price, newprice):
    method get_credit_interest (line 258) | def get_credit_interest(self, data, pos, dt):
    method _get_credit_interest (line 274) | def _get_credit_interest(self, data, size, price, days, dt0, dt1):
  class CommissionInfo (line 308) | class CommissionInfo(CommInfoBase):

FILE: backtrader/commissions/__init__.py
  class CommInfo (line 27) | class CommInfo(CommInfoBase):
  class CommInfo_Futures (line 31) | class CommInfo_Futures(CommInfoBase):
  class CommInfo_Futures_Perc (line 37) | class CommInfo_Futures_Perc(CommInfo_Futures):
  class CommInfo_Futures_Fixed (line 43) | class CommInfo_Futures_Fixed(CommInfo_Futures):
  class CommInfo_Stocks (line 49) | class CommInfo_Stocks(CommInfoBase):
  class CommInfo_Stocks_Perc (line 55) | class CommInfo_Stocks_Perc(CommInfo_Stocks):
  class CommInfo_Stocks_Fixed (line 61) | class CommInfo_Stocks_Fixed(CommInfo_Stocks):

FILE: backtrader/dataseries.py
  class TimeFrame (line 33) | class TimeFrame(object):
    method getname (line 43) | def getname(cls, tframe, compression=None):
    method TFrame (line 52) | def TFrame(cls, name):
    method TName (line 56) | def TName(cls, tframe):
  class DataSeries (line 60) | class DataSeries(LineSeries):
    method getwriterheaders (line 71) | def getwriterheaders(self):
    method getwritervalues (line 82) | def getwritervalues(self):
    method getwriterinfo (line 97) | def getwriterinfo(self):
  class OHLC (line 107) | class OHLC(DataSeries):
  class OHLCDateTime (line 111) | class OHLCDateTime(OHLC):
  class SimpleFilterWrapper (line 115) | class SimpleFilterWrapper(object):
    method __init__ (line 128) | def __init__(self, data, ffilter, *args, **kwargs):
    method __call__ (line 138) | def __call__(self, data):
  class _Bar (line 146) | class _Bar(AutoOrderedDict):
    method __init__ (line 163) | def __init__(self, maxdate=False):
    method bstart (line 167) | def bstart(self, maxdate=False):
    method isopen (line 178) | def isopen(self):
    method bupdate (line 187) | def bupdate(self, data, reopen=False):

FILE: backtrader/errors.py
  class BacktraderError (line 28) | class BacktraderError(Exception):
  class StrategySkipError (line 33) | class StrategySkipError(BacktraderError):
  class ModuleImportError (line 39) | class ModuleImportError(BacktraderError):
    method __init__ (line 42) | def __init__(self, message, *args):
  class FromModuleImportError (line 47) | class FromModuleImportError(ModuleImportError):
    method __init__ (line 50) | def __init__(self, message, *args):

FILE: backtrader/feed.py
  class MetaAbstractDataBase (line 41) | class MetaAbstractDataBase(dataseries.OHLCDateTime.__class__):
    method __init__ (line 44) | def __init__(cls, name, bases, dct):
    method dopreinit (line 55) | def dopreinit(cls, _obj, *args, **kwargs):
    method dopostinit (line 68) | def dopostinit(cls, _obj, *args, **kwargs):
  class AbstractDataBase (line 122) | class AbstractDataBase(with_metaclass(MetaAbstractDataBase,
    method _getstatusname (line 149) | def _getstatusname(cls, status):
    method _start_finish (line 167) | def _start_finish(self):
    method _start (line 202) | def _start(self):
    method _timeoffset (line 208) | def _timeoffset(self):
    method _getnexteos (line 211) | def _getnexteos(self):
    method _gettzinput (line 237) | def _gettzinput(self):
    method _gettz (line 241) | def _gettz(self):
    method date2num (line 246) | def date2num(self, dt):
    method num2date (line 252) | def num2date(self, dt=None, tz=None, naive=True):
    method haslivedata (line 258) | def haslivedata(self):
    method do_qcheck (line 261) | def do_qcheck(self, onoff, qlapse):
    method islive (line 268) | def islive(self):
    method put_notification (line 274) | def put_notification(self, status, *args, **kwargs):
    method get_notifications (line 280) | def get_notifications(self):
    method getfeed (line 294) | def getfeed(self):
    method qbuffer (line 297) | def qbuffer(self, savemem=0, replaying=False):
    method start (line 302) | def start(self):
    method stop (line 307) | def stop(self):
    method clone (line 310) | def clone(self, **kwargs):
    method copyas (line 313) | def copyas(self, _dataname, **kwargs):
    method setenvironment (line 319) | def setenvironment(self, env):
    method getenvironment (line 323) | def getenvironment(self):
    method addfilter_simple (line 326) | def addfilter_simple(self, f, *args, **kwargs):
    method addfilter (line 330) | def addfilter(self, p, *args, **kwargs):
    method compensate (line 341) | def compensate(self, other):
    method _tick_nullify (line 347) | def _tick_nullify(self):
    method _tick_fill (line 358) | def _tick_fill(self, force=False):
    method advance_peek (line 369) | def advance_peek(self):
    method advance (line 375) | def advance(self, size=1, datamaster=None, ticks=True):
    method next (line 400) | def next(self, datamaster=None, ticks=True):
    method preload (line 438) | def preload(self):
    method _last (line 445) | def _last(self, datamaster=None):
    method _check (line 464) | def _check(self, forcedata=None):
    method load (line 471) | def load(self):
    method _load (line 538) | def _load(self):
    method _add2stack (line 541) | def _add2stack(self, bar, stash=False):
    method _save2stack (line 548) | def _save2stack(self, erase=False, force=False, stash=False):
    method _updatebar (line 562) | def _updatebar(self, bar, forward=False, ago=0):
    method _fromstack (line 573) | def _fromstack(self, forward=False, stash=False):
    method resample (line 592) | def resample(self, **kwargs):
    method replay (line 595) | def replay(self, **kwargs):
  class DataBase (line 599) | class DataBase(AbstractDataBase):
  class FeedBase (line 603) | class FeedBase(with_metaclass(metabase.MetaParams, object)):
    method __init__ (line 606) | def __init__(self):
    method start (line 609) | def start(self):
    method stop (line 613) | def stop(self):
    method getdata (line 617) | def getdata(self, dataname, name=None, **kwargs):
    method _getdata (line 629) | def _getdata(self, dataname, **kwargs):
  class MetaCSVDataBase (line 637) | class MetaCSVDataBase(DataBase.__class__):
    method dopostinit (line 638) | def dopostinit(cls, _obj, *args, **kwargs):
  class CSVDataBase (line 649) | class CSVDataBase(with_metaclass(MetaCSVDataBase, DataBase)):
    method start (line 667) | def start(self):
    method stop (line 682) | def stop(self):
    method preload (line 688) | def preload(self):
    method _load (line 699) | def _load(self):
    method _getnextline (line 713) | def _getnextline(self):
  class CSVFeedBase (line 728) | class CSVFeedBase(FeedBase):
    method _getdata (line 731) | def _getdata(self, dataname, **kwargs):
  class DataClone (line 736) | class DataClone(AbstractDataBase):
    method __init__ (line 739) | def __init__(self):
    method _start (line 752) | def _start(self):
    method start (line 773) | def start(self):
    method preload (line 778) | def preload(self):
    method _load (line 784) | def _load(self):
    method advance (line 811) | def advance(self, size=1, datamaster=None, ticks=True):

FILE: backtrader/feeds/blaze.py
  class BlazeData (line 28) | class BlazeData(feed.DataBase):
    method start (line 59) | def start(self):
    method _load (line 65) | def _load(self):

FILE: backtrader/feeds/btcsv.py
  class BacktraderCSVData (line 30) | class BacktraderCSVData(feed.CSVDataBase):
    method _loadline (line 39) | def _loadline(self, linetokens):
  class BacktraderCSV (line 62) | class BacktraderCSV(feed.CSVFeedBase):

FILE: backtrader/feeds/chainer.py
  class MetaChainer (line 31) | class MetaChainer(bt.DataBase.__class__):
    method __init__ (line 32) | def __init__(cls, name, bases, dct):
    method donew (line 37) | def donew(cls, *args, **kwargs):
  class Chainer (line 49) | class Chainer(bt.with_metaclass(MetaChainer, bt.DataBase)):
    method islive (line 52) | def islive(self):
    method __init__ (line 57) | def __init__(self, *args):
    method start (line 60) | def start(self):
    method stop (line 71) | def stop(self):
    method get_notifications (line 76) | def get_notifications(self):
    method _gettz (line 79) | def _gettz(self):
    method _load (line 86) | def _load(self):

FILE: backtrader/feeds/csvgeneric.py
  class GenericCSVData (line 32) | class GenericCSVData(feed.CSVDataBase):
    method start (line 87) | def start(self):
    method _loadline (line 103) | def _loadline(self, linetokens):
  class GenericCSV (line 161) | class GenericCSV(feed.CSVFeedBase):

FILE: backtrader/feeds/ibdata.py
  class MetaIBData (line 35) | class MetaIBData(DataBase.__class__):
    method __init__ (line 36) | def __init__(cls, name, bases, dct):
  class IBData (line 45) | class IBData(with_metaclass(MetaIBData, DataBase)):
    method _timeoffset (line 219) | def _timeoffset(self):
    method _gettz (line 222) | def _gettz(self):
    method islive (line 255) | def islive(self):
    method __init__ (line 260) | def __init__(self, **kwargs):
    method setenvironment (line 265) | def setenvironment(self, env):
    method parsecontract (line 271) | def parsecontract(self, dataname):
    method start (line 342) | def start(self):
    method stop (line 407) | def stop(self):
    method reqdata (line 412) | def reqdata(self):
    method canceldata (line 425) | def canceldata(self):
    method haslivedata (line 435) | def haslivedata(self):
    method _load (line 438) | def _load(self):
    method _st_start (line 631) | def _st_start(self):
    method _load_rtbar (line 664) | def _load_rtbar(self, rtbar, hist=False):
    method _load_rtvolume (line 684) | def _load_rtvolume(self, rtvol):

FILE: backtrader/feeds/influxfeed.py
  class InfluxDB (line 41) | class InfluxDB(feed.DataBase):
    method start (line 63) | def start(self):
    method _load (line 100) | def _load(self):

FILE: backtrader/feeds/mt4csv.py
  class MT4CSVData (line 29) | class MT4CSVData(GenericCSVData):

FILE: backtrader/feeds/oanda.py
  class MetaOandaData (line 34) | class MetaOandaData(DataBase.__class__):
    method __init__ (line 35) | def __init__(cls, name, bases, dct):
  class OandaData (line 44) | class OandaData(with_metaclass(MetaOandaData, DataBase)):
    method _timeoffset (line 161) | def _timeoffset(self):
    method islive (line 165) | def islive(self):
    method __init__ (line 170) | def __init__(self, **kwargs):
    method setenvironment (line 174) | def setenvironment(self, env):
    method start (line 180) | def start(self):
    method _st_start (line 217) | def _st_start(self, instart=True, tmout=None):
    method stop (line 252) | def stop(self):
    method haslivedata (line 257) | def haslivedata(self):
    method _load (line 260) | def _load(self):
    method _load_tick (line 398) | def _load_tick(self, msg):
    method _load_history (line 420) | def _load_history(self, msg):

FILE: backtrader/feeds/pandafeed.py
  class PandasDirectData (line 30) | class PandasDirectData(feed.DataBase):
    method start (line 61) | def start(self):
    method _load (line 67) | def _load(self):
  class PandasData (line 107) | class PandasData(feed.DataBase):
    method __init__ (line 163) | def __init__(self):
    method start (line 204) | def start(self):
    method _load (line 234) | def _load(self):

FILE: backtrader/feeds/quandl.py
  class QuandlCSV (line 39) | class QuandlCSV(feed.CSVDataBase):
    method start (line 76) | def start(self):
    method _loadline (line 95) | def _loadline(self, linetokens):
  class Quandl (line 131) | class Quandl(QuandlCSV):
    method start (line 189) | def start(self):

FILE: backtrader/feeds/rollover.py
  class MetaRollOver (line 30) | class MetaRollOver(bt.DataBase.__class__):
    method __init__ (line 31) | def __init__(cls, name, bases, dct):
    method donew (line 36) | def donew(cls, *args, **kwargs):
  class RollOver (line 48) | class RollOver(bt.with_metaclass(MetaRollOver, bt.DataBase)):
    method islive (line 109) | def islive(self):
    method __init__ (line 114) | def __init__(self, *args):
    method start (line 117) | def start(self):
    method stop (line 129) | def stop(self):
    method _gettz (line 134) | def _gettz(self):
    method _checkdate (line 141) | def _checkdate(self, dt, d):
    method _checkcondition (line 147) | def _checkcondition(self, d0, d1):
    method _load (line 153) | def _load(self):

FILE: backtrader/feeds/sierrachart.py
  class SierraChartCSVData (line 28) | class SierraChartCSVData(GenericCSVData):

FILE: backtrader/feeds/vcdata.py
  class MetaVCData (line 37) | class MetaVCData(DataBase.__class__):
    method __init__ (line 38) | def __init__(cls, name, bases, dct):
  class VCData (line 47) | class VCData(with_metaclass(MetaVCData, DataBase)):
    method _timeoffset (line 172) | def _timeoffset(self):
    method _gettzinput (line 176) | def _gettzinput(self):
    method _gettz (line 180) | def _gettz(self, tzin=False):
    method islive (line 241) | def islive(self):
    method __init__ (line 246) | def __init__(self, **kwargs):
    method setenvironment (line 264) | def setenvironment(self, env):
    method start (line 270) | def start(self):
    method stop (line 362) | def stop(self):
    method _setserie (line 368) | def _setserie(self, serie):
    method haslivedata (line 372) | def haslivedata(self):
    method _load (line 375) | def _load(self):
    method _getpingtmout (line 437) | def _getpingtmout(self):
    method OnNewDataSerieBar (line 448) | def OnNewDataSerieBar(self, DataSerie, forcepush=False):
    method ping (line 486) | def ping(self):
    method OnInternalEvent (line 517) | def OnInternalEvent(self, p1, p2, p3):
    method OnNewTicks (line 529) | def OnNewTicks(self, ArrayTicks):
    method debug_ticks (line 580) | def debug_ticks(self, ticks):

FILE: backtrader/feeds/vchart.py
  class VChartData (line 33) | class VChartData(feed.DataBase):
    method start (line 49) | def start(self):
    method stop (line 87) | def stop(self):
    method _load (line 92) | def _load(self):
  class VChartFeed (line 128) | class VChartFeed(feed.FeedBase):
    method _getdata (line 133) | def _getdata(self, dataname, **kwargs):

FILE: backtrader/feeds/vchartcsv.py
  class VChartCSVData (line 31) | class VChartCSVData(feed.CSVDataBase):
    method _loadline (line 46) | def _loadline(self, linetokens):
  class VChartCSV (line 85) | class VChartCSV(feed.CSVFeedBase):

FILE: backtrader/feeds/vchartfile.py
  class MetaVChartFile (line 32) | class MetaVChartFile(bt.DataBase.__class__):
    method __init__ (line 33) | def __init__(cls, name, bases, dct):
  class VChartFile (line 42) | class VChartFile(bt.with_metaclass(MetaVChartFile, bt.DataBase)):
    method start (line 53) | def start(self):
    method stop (line 91) | def stop(self):
    method _load (line 96) | def _load(self):

FILE: backtrader/feeds/yahoo.py
  class YahooFinanceCSVData (line 37) | class YahooFinanceCSVData(feed.CSVDataBase):
    method start (line 93) | def start(self):
    method _loadline (line 110) | def _loadline(self, linetokens):
  class YahooLegacyCSV (line 181) | class YahooLegacyCSV(YahooFinanceCSVData):
  class YahooFinanceCSV (line 192) | class YahooFinanceCSV(feed.CSVFeedBase):
  class YahooFinanceData (line 196) | class YahooFinanceData(YahooFinanceCSVData):
    method start_v7 (line 253) | def start_v7(self):
    method start (line 352) | def start(self):
  class YahooFinance (line 359) | class YahooFinance(feed.CSVFeedBase):

FILE: backtrader/fillers.py
  class FixedSize (line 30) | class FixedSize(with_metaclass(MetaParams, object)):
    method __call__ (line 47) | def __call__(self, order, price, ago):
  class FixedBarPerc (line 52) | class FixedBarPerc(with_metaclass(MetaParams, object)):
    method __call__ (line 66) | def __call__(self, order, price, ago):
  class BarPointPerc (line 73) | class BarPointPerc(with_metaclass(MetaParams, object)):
    method __call__ (line 99) | def __call__(self, order, price, ago):

FILE: backtrader/filters/bsplitter.py
  class DaySplitter_Close (line 29) | class DaySplitter_Close(bt.with_metaclass(bt.MetaParams, object)):
    method __init__ (line 64) | def __init__(self, data):
    method __call__ (line 67) | def __call__(self, data):

FILE: backtrader/filters/calendardays.py
  class CalendarDays (line 31) | class CalendarDays(with_metaclass(metabase.MetaParams, object)):
    method __init__ (line 58) | def __init__(self, data):
    method __call__ (line 61) | def __call__(self, data):
    method _fillbars (line 80) | def _fillbars(self, data, dt, lastdt):

FILE: backtrader/filters/datafiller.py
  class DataFiller (line 30) | class DataFiller(AbstractDataBase):
    method start (line 61) | def start(self):
    method preload (line 66) | def preload(self):
    method _copyfromdata (line 79) | def _copyfromdata(self):
    method _frombars (line 88) | def _frombars(self):
    method _load (line 110) | def _load(self):

FILE: backtrader/filters/datafilter.py
  class DataFilter (line 27) | class DataFilter(bt.AbstractDataBase):
    method preload (line 44) | def preload(self):
    method _load (line 57) | def _load(self):

FILE: backtrader/filters/daysteps.py
  class BarReplayer_Open (line 25) | class BarReplayer_Open(object):
    method __init__ (line 39) | def __init__(self, data):
    method __call__ (line 44) | def __call__(self, data):
    method last (line 70) | def last(self, data):

FILE: backtrader/filters/heikinashi.py
  class HeikinAshi (line 28) | class HeikinAshi(object):
    method __init__ (line 38) | def __init__(self, data):
    method __call__ (line 41) | def __call__(self, data):

FILE: backtrader/filters/renko.py
  class Renko (line 31) | class Renko(Filter):
    method nextstart (line 75) | def nextstart(self, data):
    method next (line 85) | def next(self, data):

FILE: backtrader/filters/session.py
  class SessionFiller (line 31) | class SessionFiller(with_metaclass(metabase.MetaParams, object)):
    method __init__ (line 73) | def __init__(self, data):
    method __call__ (line 81) | def __call__(self, data):
    method _fillbars (line 142) | def _fillbars(self, data, time_start, time_end, tostack=True):
    method _fillbar (line 161) | def _fillbar(self, data, dtime):
  class SessionFilterSimple (line 187) | class SessionFilterSimple(with_metaclass(metabase.MetaParams, object)):
    method __init__ (line 201) | def __init__(self, data):
    method __call__ (line 204) | def __call__(self, data):
  class SessionFilter (line 216) | class SessionFilter(with_metaclass(metabase.MetaParams, object)):
    method __init__ (line 227) | def __init__(self, data):
    method __call__ (line 230) | def __call__(self, data):

FILE: backtrader/flt.py
  class MetaFilter (line 32) | class MetaFilter(MetaParams):
  class Filter (line 36) | class Filter(with_metaclass(MetaParams, object)):
    method __init__ (line 40) | def __init__(self, data):
    method __call__ (line 43) | def __call__(self, data):
    method nextstart (line 50) | def nextstart(self, data):
    method next (line 53) | def next(self, data):

FILE: backtrader/functions.py
  class List (line 32) | class List(list):
    method __contains__ (line 33) | def __contains__(self, other):
  class Logic (line 37) | class Logic(LineActions):
    method __init__ (line 38) | def __init__(self, *args):
  class DivByZero (line 43) | class DivByZero(Logic):
    method __init__ (line 54) | def __init__(self, a, b, zero=0.0):
    method next (line 60) | def next(self):
    method once (line 64) | def once(self, start, end):
  class DivZeroByZero (line 76) | class DivZeroByZero(Logic):
    method __init__ (line 88) | def __init__(self, a, b, single=float('inf'), dual=0.0):
    method next (line 95) | def next(self):
    method once (line 103) | def once(self, start, end):
  class Cmp (line 120) | class Cmp(Logic):
    method __init__ (line 121) | def __init__(self, a, b):
    method next (line 126) | def next(self):
    method once (line 129) | def once(self, start, end):
  class CmpEx (line 139) | class CmpEx(Logic):
    method __init__ (line 140) | def __init__(self, a, b, r1, r2, r3):
    method next (line 148) | def next(self):
    method once (line 151) | def once(self, start, end):
  class If (line 172) | class If(Logic):
    method __init__ (line 173) | def __init__(self, cond, a, b):
    method next (line 179) | def next(self):
    method once (line 182) | def once(self, start, end):
  class MultiLogic (line 193) | class MultiLogic(Logic):
    method next (line 194) | def next(self):
    method once (line 197) | def once(self, start, end):
  class MultiLogicReduce (line 207) | class MultiLogicReduce(MultiLogic):
    method __init__ (line 208) | def __init__(self, *args, **kwargs):
  class Reduce (line 217) | class Reduce(MultiLogicReduce):
    method __init__ (line 218) | def __init__(self, flogic, *args, **kwargs):
  function _andlogic (line 225) | def _andlogic(x, y):
  class And (line 229) | class And(MultiLogicReduce):
  function _orlogic (line 233) | def _orlogic(x, y):
  class Or (line 237) | class Or(MultiLogicReduce):
  class Max (line 241) | class Max(MultiLogic):
  class Min (line 245) | class Min(MultiLogic):
  class Sum (line 249) | class Sum(MultiLogic):
  class Any (line 253) | class Any(MultiLogic):
  class All (line 257) | class All(MultiLogic):

FILE: backtrader/indicator.py
  class MetaIndicator (line 32) | class MetaIndicator(IndicatorBase.__class__):
    method cleancache (line 40) | def cleancache(cls):
    method usecache (line 44) | def usecache(cls, onoff):
    method __call__ (line 51) | def __call__(cls, *args, **kwargs):
    method __init__ (line 67) | def __init__(cls, name, bases, dct):
  class Indicator (line 90) | class Indicator(with_metaclass(MetaIndicator, IndicatorBase)):
    method advance (line 95) | def advance(self, size=1):
    method preonce_via_prenext (line 101) | def preonce_via_prenext(self, start, end):
    method oncestart_via_nextstart (line 113) | def oncestart_via_nextstart(self, start, end):
    method once_via_next (line 126) | def once_via_next(self, start, end):
  class MtLinePlotterIndicator (line 139) | class MtLinePlotterIndicator(Indicator.__class__):
    method donew (line 140) | def donew(cls, *args, **kwargs):
  class LinePlotterIndicator (line 163) | class LinePlotterIndicator(with_metaclass(MtLinePlotterIndicator, Indica...

FILE: backtrader/indicators/accdecoscillator.py
  class AccelerationDecelerationOscillator (line 31) | class AccelerationDecelerationOscillator(bt.Indicator):
    method __init__ (line 56) | def __init__(self):

FILE: backtrader/indicators/aroon.py
  class _AroonBase (line 27) | class _AroonBase(Indicator):
    method _plotlabel (line 45) | def _plotlabel(self):
    method _plotinit (line 49) | def _plotinit(self):
    method __init__ (line 52) | def __init__(self):
  class AroonUp (line 69) | class AroonUp(_AroonBase):
    method __init__ (line 93) | def __init__(self):
  class AroonDown (line 99) | class AroonDown(_AroonBase):
    method __init__ (line 123) | def __init__(self):
  class AroonUpDown (line 129) | class AroonUpDown(AroonUp, AroonDown):
  class AroonOscillator (line 155) | class AroonOscillator(_AroonBase):
    method _plotinit (line 175) | def _plotinit(self):
    method __init__ (line 181) | def __init__(self):
  class AroonUpDownOscillator (line 187) | class AroonUpDownOscillator(AroonUpDown, AroonOscillator):

FILE: backtrader/indicators/atr.py
  class TrueHigh (line 27) | class TrueHigh(Indicator):
    method __init__ (line 43) | def __init__(self):
  class TrueLow (line 48) | class TrueLow(Indicator):
    method __init__ (line 64) | def __init__(self):
  class TrueRange (line 69) | class TrueRange(Indicator):
    method __init__ (line 91) | def __init__(self):
  class AverageTrueRange (line 96) | class AverageTrueRange(Indicator):
    method _plotlabel (line 115) | def _plotlabel(self):
    method __init__ (line 120) | def __init__(self):

FILE: backtrader/indicators/awesomeoscillator.py
  class AwesomeOscillator (line 31) | class AwesomeOscillator(bt.Indicator):
    method __init__ (line 58) | def __init__(self):

FILE: backtrader/indicators/basicops.py
  class PeriodN (line 33) | class PeriodN(Indicator):
    method __init__ (line 42) | def __init__(self):
  class OperationN (line 47) | class OperationN(PeriodN):
    method next (line 60) | def next(self):
    method once (line 63) | def once(self, start, end):
  class BaseApplyN (line 73) | class BaseApplyN(OperationN):
    method __init__ (line 88) | def __init__(self):
  class ApplyN (line 93) | class ApplyN(BaseApplyN):
  class Highest (line 103) | class Highest(OperationN):
  class Lowest (line 117) | class Lowest(OperationN):
  class ReduceN (line 131) | class ReduceN(OperationN):
    method __init__ (line 151) | def __init__(self, function, **kwargs):
  class SumN (line 161) | class SumN(OperationN):
  class AnyN (line 175) | class AnyN(OperationN):
  class AllN (line 189) | class AllN(OperationN):
  class FindFirstIndex (line 203) | class FindFirstIndex(OperationN):
    method func (line 218) | def func(self, iterable):
  class FindFirstIndexHighest (line 223) | class FindFirstIndexHighest(FindFirstIndex):
  class FindFirstIndexLowest (line 237) | class FindFirstIndexLowest(FindFirstIndex):
  class FindLastIndex (line 251) | class FindLastIndex(OperationN):
    method func (line 266) | def func(self, iterable):
  class FindLastIndexHighest (line 275) | class FindLastIndexHighest(FindLastIndex):
  class FindLastIndexLowest (line 289) | class FindLastIndexLowest(FindLastIndex):
  class Accum (line 303) | class Accum(Indicator):
    method nextstart (line 318) | def nextstart(self):
    method next (line 321) | def next(self):
    method oncestart (line 324) | def oncestart(self, start, end):
    method once (line 332) | def once(self, start, end):
  class Average (line 341) | class Average(PeriodN):
    method next (line 354) | def next(self):
    method once (line 358) | def once(self, start, end):
  class ExponentialSmoothing (line 367) | class ExponentialSmoothing(Average):
    method __init__ (line 383) | def __init__(self):
    method nextstart (line 392) | def nextstart(self):
    method next (line 396) | def next(self):
    method oncestart (line 399) | def oncestart(self, start, end):
    method once (line 403) | def once(self, start, end):
  class ExponentialSmoothingDynamic (line 415) | class ExponentialSmoothingDynamic(ExponentialSmoothing):
    method __init__ (line 433) | def __init__(self):
    method next (line 442) | def next(self):
    method once (line 446) | def once(self, start, end):
  class WeightedAverage (line 458) | class WeightedAverage(PeriodN):
    method __init__ (line 477) | def __init__(self):
    method next (line 480) | def next(self):
    method once (line 485) | def once(self, start, end):

FILE: backtrader/indicators/bollinger.py
  class BollingerBands (line 27) | class BollingerBands(Indicator):
    method _plotlabel (line 52) | def _plotlabel(self):
    method __init__ (line 57) | def __init__(self):
  class BollingerBandsPct (line 67) | class BollingerBandsPct(BollingerBands):
    method __init__ (line 74) | def __init__(self):

FILE: backtrader/indicators/cci.py
  class CommodityChannelIndex (line 27) | class CommodityChannelIndex(Indicator):
    method _plotlabel (line 53) | def _plotlabel(self):
    method _plotinit (line 58) | def _plotinit(self):
    method __init__ (line 61) | def __init__(self):

FILE: backtrader/indicators/contrib/vortex.py
  class Vortex (line 30) | class Vortex(bt.Indicator):
    method __init__ (line 42) | def __init__(self):

FILE: backtrader/indicators/crossover.py
  class NonZeroDifference (line 27) | class NonZeroDifference(Indicator):
    method nextstart (line 40) | def nextstart(self):
    method next (line 43) | def next(self):
    method oncestart (line 47) | def oncestart(self, start, end):
    method once (line 51) | def once(self, start, end):
  class _CrossBase (line 62) | class _CrossBase(Indicator):
    method __init__ (line 69) | def __init__(self):
  class CrossUp (line 82) | class CrossUp(_CrossBase):
  class CrossDown (line 97) | class CrossDown(_CrossBase):
  class CrossOver (line 112) | class CrossOver(Indicator):
    method __init__ (line 134) | def __init__(self):

FILE: backtrader/indicators/dema.py
  class DoubleExponentialMovingAverage (line 28) | class DoubleExponentialMovingAverage(MovingAverageBase):
    method __init__ (line 47) | def __init__(self):
  class TripleExponentialMovingAverage (line 55) | class TripleExponentialMovingAverage(MovingAverageBase):
    method __init__ (line 77) | def __init__(self):

FILE: backtrader/indicators/deviation.py
  class StandardDeviation (line 27) | class StandardDeviation(Indicator):
    method _plotlabel (line 53) | def _plotlabel(self):
    method __init__ (line 58) | def __init__(self):
  class MeanDeviation (line 73) | class MeanDeviation(Indicator):
    method _plotlabel (line 95) | def _plotlabel(self):
    method __init__ (line 100) | def __init__(self):

FILE: backtrader/indicators/directionalmove.py
  class UpMove (line 27) | class UpMove(Indicator):
    method __init__ (line 43) | def __init__(self):
  class DownMove (line 48) | class DownMove(Indicator):
    method __init__ (line 64) | def __init__(self):
  class _DirectionalIndicator (line 69) | class _DirectionalIndicator(Indicator):
    method _plotlabel (line 83) | def _plotlabel(self):
    method __init__ (line 88) | def __init__(self, _plus=True, _minus=True):
  class DirectionalIndicator (line 111) | class DirectionalIndicator(_DirectionalIndicator):
    method __init__ (line 143) | def __init__(self):
  class PlusDirectionalIndicator (line 150) | class PlusDirectionalIndicator(_DirectionalIndicator):
    method __init__ (line 182) | def __init__(self):
  class MinusDirectionalIndicator (line 188) | class MinusDirectionalIndicator(_DirectionalIndicator):
    method __init__ (line 220) | def __init__(self):
  class AverageDirectionalMovementIndex (line 226) | class AverageDirectionalMovementIndex(_DirectionalIndicator):
    method __init__ (line 263) | def __init__(self):
  class AverageDirectionalMovementIndexRating (line 270) | class AverageDirectionalMovementIndexRating(AverageDirectionalMovementIn...
    method __init__ (line 309) | def __init__(self):
  class DirectionalMovementIndex (line 315) | class DirectionalMovementIndex(AverageDirectionalMovementIndex,
  class DirectionalMovement (line 350) | class DirectionalMovement(AverageDirectionalMovementIndexRating,

FILE: backtrader/indicators/dma.py
  class DicksonMovingAverage (line 28) | class DicksonMovingAverage(MovingAverageBase):
    method _plotlabel (line 63) | def _plotlabel(self):
    method __init__ (line 69) | def __init__(self):

FILE: backtrader/indicators/dpo.py
  class DetrendedPriceOscillator (line 28) | class DetrendedPriceOscillator(Indicator):
    method _plotlabel (line 56) | def _plotlabel(self):
    method __init__ (line 61) | def __init__(self):

FILE: backtrader/indicators/dv2.py
  class DV2 (line 31) | class DV2(Indicator):
    method __init__ (line 50) | def __init__(self):

FILE: backtrader/indicators/ema.py
  class ExponentialMovingAverage (line 27) | class ExponentialMovingAverage(MovingAverageBase):
    method __init__ (line 45) | def __init__(self):

FILE: backtrader/indicators/envelope.py
  class EnvelopeMixIn (line 29) | class EnvelopeMixIn(object):
    method __init__ (line 51) | def __init__(self):
  class _EnvelopeBase (line 62) | class _EnvelopeBase(Indicator):
    method __init__ (line 71) | def __init__(self):
  class Envelope (line 76) | class Envelope(_EnvelopeBase, EnvelopeMixIn):

FILE: backtrader/indicators/hadelta.py
  class haDelta (line 32) | class haDelta(bt.Indicator):
    method __init__ (line 66) | def __init__(self):

FILE: backtrader/indicators/heikinashi.py
  class HeikinAshi (line 32) | class HeikinAshi(bt.Indicator):
    method __init__ (line 59) | def __init__(self):
    method prenext (line 72) | def prenext(self):

FILE: backtrader/indicators/hma.py
  class HullMovingAverage (line 29) | class HullMovingAverage(MovingAverageBase):
    method __init__ (line 58) | def __init__(self):

FILE: backtrader/indicators/hurst.py
  class HurstExponent (line 30) | class HurstExponent(PeriodN):
    method _plotlabel (line 71) | def _plotlabel(self):
    method __init__ (line 77) | def __init__(self):
    method next (line 85) | def next(self):

FILE: backtrader/indicators/ichimoku.py
  class Ichimoku (line 28) | class Ichimoku(bt.Indicator):
    method __init__ (line 67) | def __init__(self):

FILE: backtrader/indicators/kama.py
  class AdaptiveMovingAverage (line 27) | class AdaptiveMovingAverage(MovingAverageBase):
    method __init__ (line 64) | def __init__(self):

FILE: backtrader/indicators/kst.py
  class KnowSureThing (line 28) | class KnowSureThing(bt.Indicator):
    method __init__ (line 68) | def __init__(self):

FILE: backtrader/indicators/lrsi.py
  class LaguerreRSI (line 30) | class LaguerreRSI(PeriodN):
    method next (line 56) | def next(self):
  class LaguerreFilter (line 88) | class LaguerreFilter(PeriodN):
    method next (line 103) | def next(self):

FILE: backtrader/indicators/mabase.py
  class MovingAverage (line 29) | class MovingAverage(object):
    method register (line 52) | def register(cls, regcls):
  class MovAv (line 71) | class MovAv(MovingAverage):
  class MetaMovAvBase (line 75) | class MetaMovAvBase(Indicator.__class__):
    method __new__ (line 79) | def __new__(meta, name, bases, dct):
  class MovingAverageBase (line 89) | class MovingAverageBase(with_metaclass(MetaMovAvBase, Indicator)):

FILE: backtrader/indicators/macd.py
  class MACD (line 27) | class MACD(Indicator):
    method _plotlabel (line 51) | def _plotlabel(self):
    method __init__ (line 57) | def __init__(self):
  class MACDHisto (line 66) | class MACDHisto(MACD):
    method __init__ (line 82) | def __init__(self):

FILE: backtrader/indicators/momentum.py
  class Momentum (line 27) | class Momentum(Indicator):
    method __init__ (line 43) | def __init__(self):
  class MomentumOscillator (line 48) | class MomentumOscillator(Indicator):
    method _plotlabel (line 67) | def _plotlabel(self):
    method _plotinit (line 71) | def _plotinit(self):
    method __init__ (line 74) | def __init__(self):
  class RateOfChange (line 79) | class RateOfChange(Indicator):
    method __init__ (line 97) | def __init__(self):
  class RateOfChange100 (line 103) | class RateOfChange100(Indicator):
    method __init__ (line 124) | def __init__(self):

FILE: backtrader/indicators/ols.py
  class OLS_Slope_InterceptN (line 32) | class OLS_Slope_InterceptN(PeriodN):
    method next (line 50) | def next(self):
  class OLS_TransformationN (line 60) | class OLS_TransformationN(PeriodN):
    method __init__ (line 70) | def __init__(self):
  class OLS_BetaN (line 81) | class OLS_BetaN(PeriodN):
    method next (line 96) | def next(self):
  class CointN (line 102) | class CointN(PeriodN):
    method next (line 124) | def next(self):

FILE: backtrader/indicators/oscillator.py
  class OscillatorMixIn (line 30) | class OscillatorMixIn(Indicator):
    method _plotinit (line 46) | def _plotinit(self):
    method __init__ (line 53) | def __init__(self):
  class Oscillator (line 58) | class Oscillator(Indicator):
    method _plotinit (line 83) | def _plotinit(self):
    method __init__ (line 90) | def __init__(self):

FILE: backtrader/indicators/percentchange.py
  class PercentChange (line 30) | class PercentChange(Indicator):
    method __init__ (line 44) | def __init__(self):

FILE: backtrader/indicators/percentrank.py
  class PercentRank (line 32) | class PercentRank(BaseApplyN):

FILE: backtrader/indicators/pivotpoint.py
  class PivotPoint (line 27) | class PivotPoint(Indicator):
    method _plotinit (line 74) | def _plotinit(self):
    method __init__ (line 80) | def __init__(self):
  class FibonacciPivotPoint (line 106) | class FibonacciPivotPoint(Indicator):
    method _plotinit (line 158) | def _plotinit(self):
    method __init__ (line 164) | def __init__(self):
  class DemarkPivotPoint (line 192) | class DemarkPivotPoint(Indicator):
    method _plotinit (line 245) | def _plotinit(self):
    method __init__ (line 251) | def __init__(self):

FILE: backtrader/indicators/prettygoodoscillator.py
  class PrettyGoodOscillator (line 28) | class PrettyGoodOscillator(Indicator):
    method __init__ (line 55) | def __init__(self):

FILE: backtrader/indicators/priceoscillator.py
  class _PriceOscBase (line 27) | class _PriceOscBase(Indicator):
    method __init__ (line 33) | def __init__(self):
  class PriceOscillator (line 41) | class PriceOscillator(_PriceOscBase):
  class PercentagePriceOscillator (line 56) | class PercentagePriceOscillator(_PriceOscBase):
    method __init__ (line 81) | def __init__(self):
  class PercentagePriceOscillatorShort (line 91) | class PercentagePriceOscillatorShort(PercentagePriceOscillator):

FILE: backtrader/indicators/psar.py
  class _SarStatus (line 30) | class _SarStatus(object):
    method __str__ (line 36) | def __str__(self):
  class ParabolicSAR (line 45) | class ParabolicSAR(PeriodN):
    method prenext (line 75) | def prenext(self):
    method nextstart (line 87) | def nextstart(self):
    method next (line 119) | def next(self):

FILE: backtrader/indicators/rmi.py
  class RelativeMomentumIndex (line 27) | class RelativeMomentumIndex(RSI):
    method _plotlabel (line 58) | def _plotlabel(self):

FILE: backtrader/indicators/rsi.py
  class UpDay (line 28) | class UpDay(Indicator):
    method __init__ (line 45) | def __init__(self):
  class DownDay (line 50) | class DownDay(Indicator):
    method __init__ (line 67) | def __init__(self):
  class UpDayBool (line 72) | class UpDayBool(Indicator):
    method __init__ (line 92) | def __init__(self):
  class DownDayBool (line 97) | class DownDayBool(Indicator):
    method __init__ (line 117) | def __init__(self):
  class RelativeStrengthIndex (line 122) | class RelativeStrengthIndex(Indicator):
    method _plotlabel (line 169) | def _plotlabel(self):
    method _plotinit (line 175) | def _plotinit(self):
    method __init__ (line 178) | def __init__(self):
    method _rscalc (line 193) | def _rscalc(self, rsi):
  class RSI_Safe (line 202) | class RSI_Safe(RSI):
  class RSI_SMA (line 213) | class RSI_SMA(RSI):
  class RSI_EMA (line 225) | class RSI_EMA(RSI):

FILE: backtrader/indicators/sma.py
  class MovingAverageSimple (line 27) | class MovingAverageSimple(MovingAverageBase):
    method __init__ (line 40) | def __init__(self):

FILE: backtrader/indicators/smma.py
  class SmoothedMovingAverage (line 27) | class SmoothedMovingAverage(MovingAverageBase):
    method __init__ (line 51) | def __init__(self):

FILE: backtrader/indicators/stochastic.py
  class _StochasticBase (line 27) | class _StochasticBase(Indicator):
    method _plotlabel (line 36) | def _plotlabel(self):
    method _plotinit (line 41) | def _plotinit(self):
    method __init__ (line 44) | def __init__(self):
  class StochasticFast (line 58) | class StochasticFast(_StochasticBase):
    method __init__ (line 81) | def __init__(self):
  class Stochastic (line 87) | class Stochastic(_StochasticBase):
    method _plotlabel (line 106) | def _plotlabel(self):
    method __init__ (line 111) | def __init__(self):
  class StochasticFull (line 117) | class StochasticFull(_StochasticBase):
    method _plotlabel (line 138) | def _plotlabel(self):
    method __init__ (line 143) | def __init__(self):

FILE: backtrader/indicators/trix.py
  class Trix (line 27) | class Trix(Indicator):
    method _plotlabel (line 53) | def _plotlabel(self):
    method __init__ (line 59) | def __init__(self):
  class TrixSignal (line 71) | class TrixSignal(Trix):
    method __init__ (line 85) | def __init__(self):

FILE: backtrader/indicators/tsi.py
  class TrueStrengthIndicator (line 29) | class TrueStrengthIndicator(bt.Indicator):
    method __init__ (line 65) | def __init__(self):

FILE: backtrader/indicators/ultimateoscillator.py
  class UltimateOscillator (line 29) | class UltimateOscillator(bt.Indicator):
    method _plotinit (line 59) | def _plotinit(self):
    method __init__ (line 68) | def __init__(self):

FILE: backtrader/indicators/vortex.py
  class Vortex (line 27) | class Vortex(bt.Indicator):
    method __init__ (line 39) | def __init__(self):

FILE: backtrader/indicators/williams.py
  class WilliamsR (line 28) | class WilliamsR(Indicator):
    method _plotinif (line 51) | def _plotinif(self):
    method __init__ (line 54) | def __init__(self):
  class WilliamsAD (line 64) | class WilliamsAD(Indicator):
    method __init__ (line 80) | def __init__(self):

FILE: backtrader/indicators/wma.py
  class WeightedMovingAverage (line 29) | class WeightedMovingAverage(MovingAverageBase):
    method __init__ (line 45) | def __init__(self):

FILE: backtrader/indicators/zlema.py
  class ZeroLagExponentialMovingAverage (line 28) | class ZeroLagExponentialMovingAverage(MovingAverageBase):
    method __init__ (line 46) | def __init__(self):

FILE: backtrader/indicators/zlind.py
  class ZeroLagIndicator (line 32) | class ZeroLagIndicator(MovingAverageBase):
    method _plotlabel (line 64) | def _plotlabel(self):
    method __init__ (line 69) | def __init__(self):
    method next (line 76) | def next(self):

FILE: backtrader/linebuffer.py
  class LineBuffer (line 50) | class LineBuffer(LineSingle):
    method __init__ (line 75) | def __init__(self):
    method get_idx (line 82) | def get_idx(self):
    method set_idx (line 85) | def set_idx(self, idx, force=False):
    method reset (line 102) | def reset(self):
    method qbuffer (line 121) | def qbuffer(self, savemem=0, extrasize=0):
    method getindicators (line 128) | def getindicators(self):
    method minbuffer (line 131) | def minbuffer(self, size):
    method __len__ (line 149) | def __len__(self):
    method buflen (line 152) | def buflen(self):
    method __getitem__ (line 162) | def __getitem__(self, ago):
    method get (line 165) | def get(self, ago=0, size=1):
    method getzeroval (line 186) | def getzeroval(self, idx=0):
    method getzero (line 199) | def getzero(self, idx=0, size=1):
    method __setitem__ (line 214) | def __setitem__(self, ago, value):
    method set (line 226) | def set(self, value, ago=0):
    method home (line 238) | def home(self):
    method forward (line 247) | def forward(self, value=NAN, size=1):
    method backwards (line 260) | def backwards(self, size=1, force=False):
    method rewind (line 273) | def rewind(self, size=1):
    method advance (line 277) | def advance(self, size=1):
    method extend (line 286) | def extend(self, value=NAN, size=0):
    method addbinding (line 300) | def addbinding(self, binding):
    method plot (line 312) | def plot(self, idx=0, size=None):
    method plotrange (line 328) | def plotrange(self, start, end):
    method oncebinding (line 334) | def oncebinding(self):
    method bind2lines (line 343) | def bind2lines(self, binding=0):
    method __call__ (line 358) | def __call__(self, ago=None):
    method _makeoperation (line 376) | def _makeoperation(self, other, operation, r=False, _ownerskip=None):
    method _makeoperationown (line 380) | def _makeoperationown(self, operation, _ownerskip=None):
    method _settz (line 383) | def _settz(self, tz):
    method datetime (line 386) | def datetime(self, ago=0, tz=None, naive=True):
    method date (line 390) | def date(self, ago=0, tz=None, naive=True):
    method time (line 394) | def time(self, ago=0, tz=None, naive=True):
    method dt (line 398) | def dt(self, ago=0):
    method tm_raw (line 404) | def tm_raw(self, ago=0):
    method tm (line 413) | def tm(self, ago=0):
    method tm_lt (line 422) | def tm_lt(self, other, ago=0):
    method tm_le (line 434) | def tm_le(self, other, ago=0):
    method tm_eq (line 446) | def tm_eq(self, other, ago=0):
    method tm_gt (line 458) | def tm_gt(self, other, ago=0):
    method tm_ge (line 470) | def tm_ge(self, other, ago=0):
    method tm2dtime (line 482) | def tm2dtime(self, tm, ago=0):
    method tm2datetime (line 490) | def tm2datetime(self, tm, ago=0):
  class MetaLineActions (line 499) | class MetaLineActions(LineBuffer.__class__):
    method cleancache (line 513) | def cleancache(cls):
    method usecache (line 517) | def usecache(cls, onoff):
    method __call__ (line 520) | def __call__(cls, *args, **kwargs):
    method dopreinit (line 536) | def dopreinit(cls, _obj, *args, **kwargs):
    method dopostinit (line 561) | def dopostinit(cls, _obj, *args, **kwargs):
  class PseudoArray (line 571) | class PseudoArray(object):
    method __init__ (line 572) | def __init__(self, wrapped):
    method __getitem__ (line 575) | def __getitem__(self, key):
    method array (line 579) | def array(self):
  class LineActions (line 583) | class LineActions(with_metaclass(MetaLineActions, LineBuffer)):
    method getindicators (line 594) | def getindicators(self):
    method qbuffer (line 597) | def qbuffer(self, savemem=0):
    method arrayize (line 603) | def arrayize(obj):
    method _next (line 612) | def _next(self):
    method _once (line 625) | def _once(self):
  function LineDelay (line 636) | def LineDelay(a, ago=0, **kwargs):
  function LineNum (line 643) | def LineNum(num):
  class _LineDelay (line 647) | class _LineDelay(LineActions):
    method __init__ (line 652) | def __init__(self, a, ago):
    method next (line 662) | def next(self):
    method once (line 665) | def once(self, start, end):
  class _LineForward (line 675) | class _LineForward(LineActions):
    method __init__ (line 680) | def __init__(self, a, ago):
    method next (line 692) | def next(self):
    method once (line 695) | def once(self, start, end):
  class LinesOperation (line 705) | class LinesOperation(LineActions):
    method __init__ (line 727) | def __init__(self, a, b, operation, r=False):
    method next (line 742) | def next(self):
    method once (line 753) | def once(self, start, end):
    method _once_op (line 764) | def _once_op(self, start, end):
    method _once_time_op (line 774) | def _once_time_op(self, start, end):
    method _once_val_op (line 785) | def _once_val_op(self, start, end):
    method _once_val_op_r (line 795) | def _once_val_op_r(self, start, end):
  class LineOwnOperation (line 806) | class LineOwnOperation(LineActions):
    method __init__ (line 813) | def __init__(self, a, operation):
    method next (line 819) | def next(self):
    method once (line 822) | def once(self, start, end):

FILE: backtrader/lineiterator.py
  class MetaLineIterator (line 38) | class MetaLineIterator(LineSeries.__class__):
    method donew (line 39) | def donew(cls, *args, **kwargs):
    method dopreinit (line 106) | def dopreinit(cls, _obj, *args, **kwargs):
    method dopostinit (line 130) | def dopostinit(cls, _obj, *args, **kwargs):
  class LineIterator (line 148) | class LineIterator(with_metaclass(MetaLineIterator, LineSeries)):
    method _periodrecalc (line 169) | def _periodrecalc(self):
    method _stage2 (line 178) | def _stage2(self):
    method _stage1 (line 188) | def _stage1(self):
    method getindicators (line 198) | def getindicators(self):
    method getindicators_lines (line 201) | def getindicators_lines(self):
    method getobservers (line 205) | def getobservers(self):
    method addindicator (line 208) | def addindicator(self, indicator):
    method bindlines (line 223) | def bindlines(self, owner=None, own=None):
    method _next (line 259) | def _next(self):
    method _clk_update (line 286) | def _clk_update(self):
    method _once (line 293) | def _once(self):
    method preonce (line 323) | def preonce(self, start, end):
    method oncestart (line 326) | def oncestart(self, start, end):
    method once (line 329) | def once(self, start, end):
    method prenext (line 332) | def prenext(self):
    method nextstart (line 339) | def nextstart(self):
    method next (line 349) | def next(self):
    method _addnotification (line 356) | def _addnotification(self, *args, **kwargs):
    method _notify (line 359) | def _notify(self):
    method _plotinit (line 362) | def _plotinit(self):
    method qbuffer (line 365) | def qbuffer(self, savemem=0):
  class DataAccessor (line 383) | class DataAccessor(LineIterator):
  class IndicatorBase (line 393) | class IndicatorBase(DataAccessor):
  class ObserverBase (line 397) | class ObserverBase(DataAccessor):
  class StrategyBase (line 401) | class StrategyBase(DataAccessor):
  class SingleCoupler (line 408) | class SingleCoupler(LineActions):
    method __init__ (line 409) | def __init__(self, cdata, clock=None):
    method next (line 417) | def next(self):
  class MultiCoupler (line 425) | class MultiCoupler(LineIterator):
    method __init__ (line 428) | def __init__(self):
    method next (line 434) | def next(self):
  function LinesCoupler (line 445) | def LinesCoupler(cdata, clock=None, **kwargs):

FILE: backtrader/lineroot.py
  class MetaLineRoot (line 41) | class MetaLineRoot(metabase.MetaParams):
    method donew (line 47) | def donew(cls, *args, **kwargs):
  class LineRoot (line 61) | class LineRoot(with_metaclass(MetaLineRoot, object)):
    method _stage1 (line 77) | def _stage1(self):
    method _stage2 (line 80) | def _stage2(self):
    method _operation (line 83) | def _operation(self, other, operation, r=False, intify=False):
    method _operationown (line 90) | def _operationown(self, operation):
    method qbuffer (line 96) | def qbuffer(self, savemem=0):
    method minbuffer (line 100) | def minbuffer(self, size):
    method setminperiod (line 104) | def setminperiod(self, minperiod):
    method updateminperiod (line 112) | def updateminperiod(self, minperiod):
    method addminperiod (line 120) | def addminperiod(self, minperiod):
    method incminperiod (line 126) | def incminperiod(self, minperiod):
    method prenext (line 132) | def prenext(self):
    method nextstart (line 138) | def nextstart(self):
    method next (line 146) | def next(self):
    method preonce (line 152) | def preonce(self, start, end):
    method oncestart (line 158) | def oncestart(self, start, end):
    method once (line 167) | def once(self, start, end):
    method _makeoperation (line 174) | def _makeoperation(self, other, operation, r=False, _ownerskip=None):
    method _makeoperationown (line 177) | def _makeoperationown(self, operation, _ownerskip=None):
    method _operationown_stage1 (line 180) | def _operationown_stage1(self, operation):
    method _roperation (line 186) | def _roperation(self, other, operation, intify=False):
    method _operation_stage1 (line 193) | def _operation_stage1(self, other, operation, r=False, intify=False):
    method _operation_stage2 (line 203) | def _operation_stage2(self, other, operation, r=False):
    method _operationown_stage2 (line 217) | def _operationown_stage2(self, operation):
    method __add__ (line 220) | def __add__(self, other):
    method __radd__ (line 223) | def __radd__(self, other):
    method __sub__ (line 226) | def __sub__(self, other):
    method __rsub__ (line 229) | def __rsub__(self, other):
    method __mul__ (line 232) | def __mul__(self, other):
    method __rmul__ (line 235) | def __rmul__(self, other):
    method __div__ (line 238) | def __div__(self, other):
    method __rdiv__ (line 241) | def __rdiv__(self, other):
    method __floordiv__ (line 244) | def __floordiv__(self, other):
    method __rfloordiv__ (line 247) | def __rfloordiv__(self, other):
    method __truediv__ (line 250) | def __truediv__(self, other):
    method __rtruediv__ (line 253) | def __rtruediv__(self, other):
    method __pow__ (line 256) | def __pow__(self, other):
    method __rpow__ (line 259) | def __rpow__(self, other):
    method __abs__ (line 262) | def __abs__(self):
    method __neg__ (line 265) | def __neg__(self):
    method __lt__ (line 268) | def __lt__(self, other):
    method __gt__ (line 271) | def __gt__(self, other):
    method __le__ (line 274) | def __le__(self, other):
    method __ge__ (line 277) | def __ge__(self, other):
    method __eq__ (line 280) | def __eq__(self, other):
    method __ne__ (line 283) | def __ne__(self, other):
    method __nonzero__ (line 286) | def __nonzero__(self):
  class LineMultiple (line 296) | class LineMultiple(LineRoot):
    method reset (line 300) | def reset(self):
    method _stage1 (line 304) | def _stage1(self):
    method _stage2 (line 309) | def _stage2(self):
    method addminperiod (line 314) | def addminperiod(self, minperiod):
    method incminperiod (line 322) | def incminperiod(self, minperiod):
    method _makeoperation (line 330) | def _makeoperation(self, other, operation, r=False, _ownerskip=None):
    method _makeoperationown (line 333) | def _makeoperationown(self, operation, _ownerskip=None):
    method qbuffer (line 336) | def qbuffer(self, savemem=0):
    method minbuffer (line 340) | def minbuffer(self, size):
  class LineSingle (line 345) | class LineSingle(LineRoot):
    method addminperiod (line 349) | def addminperiod(self, minperiod):
    method incminperiod (line 355) | def incminperiod(self, minperiod):

FILE: backtrader/lineseries.py
  class LineAlias (line 44) | class LineAlias(object):
    method __init__ (line 58) | def __init__(self, line):
    method __get__ (line 61) | def __get__(self, obj, cls=None):
    method __set__ (line 64) | def __set__(self, obj, value):
  class Lines (line 84) | class Lines(object):
    method _derive (line 100) | def _derive(cls, name, lines, extralines, otherbases, linesoverride=Fa...
    method _getlinealias (line 182) | def _getlinealias(cls, i):
    method getlinealiases (line 193) | def getlinealiases(cls):
    method itersize (line 196) | def itersize(self):
    method __init__ (line 199) | def __init__(self, initlines=None):
    method __len__ (line 216) | def __len__(self):
    method size (line 222) | def size(self):
    method fullsize (line 225) | def fullsize(self):
    method extrasize (line 228) | def extrasize(self):
    method __getitem__ (line 231) | def __getitem__(self, line):
    method get (line 237) | def get(self, ago=0, size=1, line=0):
    method __setitem__ (line 243) | def __setitem__(self, line, value):
    method forward (line 249) | def forward(self, value=NAN, size=1):
    method backwards (line 256) | def backwards(self, size=1, force=False):
    method rewind (line 263) | def rewind(self, size=1):
    method extend (line 270) | def extend(self, value=NAN, size=0):
    method reset (line 277) | def reset(self):
    method home (line 284) | def home(self):
    method advance (line 291) | def advance(self, size=1):
    method buflen (line 298) | def buflen(self, line=0):
  class MetaLineSeries (line 305) | class MetaLineSeries(LineMultiple.__class__):
    method __new__ (line 326) | def __new__(meta, name, bases, dct):
    method donew (line 406) | def donew(cls, *args, **kwargs):
  class LineSeries (line 444) | class LineSeries(with_metaclass(MetaLineSeries, LineMultiple)):
    method array (line 454) | def array(self):
    method __getattr__ (line 457) | def __getattr__(self, name):
    method __len__ (line 463) | def __len__(self):
    method __getitem__ (line 466) | def __getitem__(self, key):
    method __setitem__ (line 469) | def __setitem__(self, key, value):
    method __init__ (line 472) | def __init__(self, *args, **kwargs):
    method plotlabel (line 480) | def plotlabel(self):
    method _plotlabel (line 497) | def _plotlabel(self):
    method _getline (line 500) | def _getline(self, line, minusall=False):
    method __call__ (line 512) | def __call__(self, ago=None, line=-1):
    method forward (line 553) | def forward(self, value=NAN, size=1):
    method backwards (line 556) | def backwards(self, size=1, force=False):
    method rewind (line 559) | def rewind(self, size=1):
    method extend (line 562) | def extend(self, value=NAN, size=0):
    method reset (line 565) | def reset(self):
    method home (line 568) | def home(self):
    method advance (line 571) | def advance(self, size=1):
  class LineSeriesStub (line 575) | class LineSeriesStub(LineSeries):
    method __init__ (line 595) | def __init__(self, line, slave=False):
    method forward (line 603) | def forward(self, value=NAN, size=1):
    method backwards (line 607) | def backwards(self, size=1, force=False):
    method rewind (line 611) | def rewind(self, size=1):
    method extend (line 615) | def extend(self, value=NAN, size=0):
    method reset (line 619) | def reset(self):
    method home (line 623) | def home(self):
    method advance (line 627) | def advance(self, size=1):
    method qbuffer (line 631) | def qbuffer(self):
    method minbuffer (line 635) | def minbuffer(self, size):
  function LineSeriesMaker (line 640) | def LineSeriesMaker(arg, slave=False):

FILE: backtrader/mathsupport.py
  function average (line 27) | def average(x, bessel=False):
  function variance (line 41) | def variance(x, avgx=None):
  function standarddev (line 54) | def standarddev(x, avgx=None, bessel=False):

FILE: backtrader/metabase.py
  function findbases (line 32) | def findbases(kls, topclass):
  function findowner (line 42) | def findowner(owned, cls, startlevel=2, skip=None):
  class MetaBase (line 66) | class MetaBase(type):
    method doprenew (line 67) | def doprenew(cls, *args, **kwargs):
    method donew (line 70) | def donew(cls, *args, **kwargs):
    method dopreinit (line 74) | def dopreinit(cls, _obj, *args, **kwargs):
    method doinit (line 77) | def doinit(cls, _obj, *args, **kwargs):
    method dopostinit (line 81) | def dopostinit(cls, _obj, *args, **kwargs):
    method __call__ (line 84) | def __call__(cls, *args, **kwargs):
  class AutoInfoClass (line 93) | class AutoInfoClass(object):
    method _derive (line 99) | def _derive(cls, name, info, otherbases, recurse=False):
    method isdefault (line 154) | def isdefault(self, pname):
    method notdefault (line 157) | def notdefault(self, pname):
    method _get (line 160) | def _get(self, name, default=None):
    method _getkwargsdefault (line 164) | def _getkwargsdefault(cls):
    method _getkeys (line 168) | def _getkeys(cls):
    method _getdefaults (line 172) | def _getdefaults(cls):
    method _getitems (line 176) | def _getitems(cls):
    method _gettuple (line 180) | def _gettuple(cls):
    method _getkwargs (line 183) | def _getkwargs(self, skip_=False):
    method _getvalues (line 189) | def _getvalues(self):
    method __new__ (line 192) | def __new__(cls, *args, **kwargs):
  class MetaParams (line 203) | class MetaParams(MetaBase):
    method __new__ (line 204) | def __new__(meta, name, bases, dct):
    method donew (line 243) | def donew(cls, *args, **kwargs):
  class ParamsBase (line 296) | class ParamsBase(with_metaclass(MetaParams, object)):
  class ItemCollection (line 300) | class ItemCollection(object):
    method __init__ (line 307) | def __init__(self):
    method __len__ (line 311) | def __len__(self):
    method append (line 314) | def append(self, item, name=None):
    method __getitem__ (line 320) | def __getitem__(self, key):
    method getnames (line 323) | def getnames(self):
    method getitems (line 326) | def getitems(self):
    method getbyname (line 329) | def getbyname(self, name):

FILE: backtrader/observer.py
  class MetaObserver (line 29) | class MetaObserver(ObserverBase.__class__):
    method donew (line 30) | def donew(cls, *args, **kwargs):
    method dopreinit (line 36) | def dopreinit(cls, _obj, *args, **kwargs):
  class Observer (line 46) | class Observer(with_metaclass(MetaObserver, ObserverBase)):
    method prenext (line 58) | def prenext(self):
    method _register_analyzer (line 61) | def _register_analyzer(self, analyzer):
    method _start (line 64) | def _start(self):
    method start (line 67) | def start(self):

FILE: backtrader/observers/benchmark.py
  class Benchmark (line 28) | class Benchmark(TimeReturn):
    method _plotlabel (line 94) | def _plotlabel(self):
    method __init__ (line 99) | def __init__(self):
    method next (line 112) | def next(self):
    method prenext (line 117) | def prenext(self):

FILE: backtrader/observers/broker.py
  class Cash (line 27) | class Cash(Observer):
    method next (line 38) | def next(self):
  class Value (line 42) | class Value(Observer):
    method start (line 68) | def start(self):
    method next (line 74) | def next(self):
  class Broker (line 81) | class Broker(Observer):
    method start (line 98) | def start(self):
    method next (line 108) | def next(self):
  class FundValue (line 116) | class FundValue(Observer):
    method next (line 128) | def next(self):
  class FundShares (line 132) | class FundShares(Observer):
    method next (line 143) | def next(self):

FILE: backtrader/observers/buysell.py
  class BuySell (line 29) | class BuySell(Observer):
    method next (line 60) | def next(self):

FILE: backtrader/observers/drawdown.py
  class DrawDown (line 28) | class DrawDown(Observer):
    method __init__ (line 56) | def __init__(self):
    method next (line 61) | def next(self):
  class DrawDownLength (line 66) | class DrawDownLength(Observer):
    method __init__ (line 80) | def __init__(self):
    method next (line 83) | def next(self):
  class DrawDown_Old (line 88) | class DrawDown_Old(Observer):
    method __init__ (line 102) | def __init__(self):
    method next (line 108) | def next(self):

FILE: backtrader/observers/logreturns.py
  class LogReturns (line 31) | class LogReturns(bt.Observer):
    method _plotlabel (line 72) | def _plotlabel(self):
    method __init__ (line 76) | def __init__(self):
    method next (line 81) | def next(self):
  class LogReturns2 (line 85) | class LogReturns2(LogReturns):
    method __init__ (line 89) | def __init__(self):
    method next (line 96) | def next(self):

FILE: backtrader/observers/timereturn.py
  class TimeReturn (line 33) | class TimeReturn(Observer):
    method _plotlabel (line 75) | def _plotlabel(self):
    method __init__ (line 83) | def __init__(self):
    method next (line 87) | def next(self):

FILE: backtrader/observers/trades.py
  class Trades (line 32) | class Trades(Observer):
    method __init__ (line 66) | def __init__(self):
    method next (line 91) | def next(self):
  class MetaDataTrades (line 107) | class MetaDataTrades(Observer.__class__):
    method donew (line 108) | def donew(cls, *args, **kwargs):
  class DataTrades (line 144) | class DataTrades(with_metaclass(MetaDataTrades, Observer)):
    method next (line 154) | def next(self):

FILE: backtrader/order.py
  class OrderExecutionBit (line 35) | class OrderExecutionBit(object):
    method __init__ (line 62) | def __init__(self,
  class OrderData (line 88) | class OrderData(object):
    method __init__ (line 130) | def __init__(self, dt=None, size=0, price=0.0, pricelimit=0.0, remsize=0,
    method _getplimit (line 163) | def _getplimit(self):
    method _setplimit (line 166) | def _setplimit(self, val):
    method __len__ (line 171) | def __len__(self):
    method __getitem__ (line 174) | def __getitem__(self, key):
    method add (line 177) | def add(self, dt, size, price,
    method addbit (line 189) | def addbit(self, exbit):
    method getpending (line 206) | def getpending(self):
    method iterpending (line 209) | def iterpending(self):
    method markpending (line 212) | def markpending(self):
    method clone (line 216) | def clone(self):
  class OrderBase (line 222) | class OrderBase(with_metaclass(MetaParams, object)):
    method _getplimit (line 262) | def _getplimit(self):
    method _setplimit (line 265) | def _setplimit(self, val):
    method __getattr__ (line 270) | def __getattr__(self, name):
    method __setattribute__ (line 274) | def __setattribute__(self, name, value):
    method __str__ (line 280) | def __str__(self):
    method __init__ (line 302) | def __init__(self):
    method clone (line 384) | def clone(self):
    method getstatusname (line 392) | def getstatusname(self, status=None):
    method getordername (line 396) | def getordername(self, exectype=None):
    method ExecType (line 401) | def ExecType(cls, exectype):
    method ordtypename (line 404) | def ordtypename(self, ordtype=None):
    method active (line 408) | def active(self):
    method activate (line 411) | def activate(self):
    method alive (line 414) | def alive(self):
    method addcomminfo (line 421) | def addcomminfo(self, comminfo):
    method addinfo (line 425) | def addinfo(self, **kwargs):
    method __eq__ (line 432) | def __eq__(self, other):
    method __ne__ (line 435) | def __ne__(self, other):
    method isbuy (line 438) | def isbuy(self):
    method issell (line 442) | def issell(self):
    method setposition (line 446) | def setposition(self, position):
    method submit (line 450) | def submit(self, broker=None):
    method accept (line 457) | def accept(self, broker=None):
    method brokerstatus (line 462) | def brokerstatus(self):
    method reject (line 471) | def reject(self, broker=None):
    method cancel (line 482) | def cancel(self):
    method margin (line 488) | def margin(self):
    method completed (line 494) | def completed(self):
    method partial (line 498) | def partial(self):
    method execute (line 502) | def execute(self, dt, size, price,
    method expire (line 519) | def expire(self):
    method trailadjust (line 524) | def trailadjust(self, price):
  class Order (line 528) | class Order(OrderBase):
    method execute (line 566) | def execute(self, dt, size, price,
    method expire (line 584) | def expire(self):
    method trailadjust (line 595) | def trailadjust(self, price):
  class BuyOrder (line 620) | class BuyOrder(Order):
  class StopBuyOrder (line 624) | class StopBuyOrder(BuyOrder):
  class StopLimitBuyOrder (line 628) | class StopLimitBuyOrder(BuyOrder):
  class SellOrder (line 632) | class SellOrder(Order):
  class StopSellOrder (line 636) | class StopSellOrder(SellOrder):
  class StopLimitSellOrder (line 640) | class StopLimitSellOrder(SellOrder):

FILE: backtrader/plot/finance.py
  class CandlestickPlotHandler (line 34) | class CandlestickPlotHandler(object):
    method __init__ (line 40) | def __init__(self,
    method legend_artist (line 102) | def legend_artist(self, legend, orig_handle, fontsize, handlebox):
    method barcollection (line 125) | def barcollection(self,
  function plot_candlestick (line 211) | def plot_candlestick(ax,
  class VolumePlotHandler (line 242) | class VolumePlotHandler(object):
    method __init__ (line 247) | def __init__(self,
    method legend_artist (line 289) | def legend_artist(self, legend, orig_handle, fontsize, handlebox):
    method barcollection (line 307) | def barcollection(self,
  function plot_volume (line 343) | def plot_volume(
  class OHLCPlotHandler (line 362) | class OHLCPlotHandler(object):
    method __init__ (line 368) | def __init__(self,
    method legend_artist (line 404) | def legend_artist(self, legend, orig_handle, fontsize, handlebox):
    method barcollection (line 429) | def barcollection(self,
  function plot_ohlc (line 495) | def plot_ohlc(ax, x, opens, highs, lows, closes,
  class LineOnClosePlotHandler (line 513) | class LineOnClosePlotHandler(object):
    method __init__ (line 516) | def __init__(self,
    method legend_artist (line 541) | def legend_artist(self, legend, orig_handle, fontsize, handlebox):
    method barcollection (line 560) | def barcollection(self,
  function plot_lineonclose (line 581) | def plot_lineonclose(ax, x, closes,

FILE: backtrader/plot/formatters.py
  class MyVolFormatter (line 30) | class MyVolFormatter(mplticker.Formatter):
    method __init__ (line 33) | def __init__(self, volmax):
    method __call__ (line 43) | def __call__(self, y, pos=0):
  class MyDateFormatter (line 53) | class MyDateFormatter(mplticker.Formatter):
    method __init__ (line 54) | def __init__(self, dates, fmt='%Y-%m-%d'):
    method __call__ (line 59) | def __call__(self, x, pos=0):
  function patch_locator (line 71) | def patch_locator(locator, xdates):
  function patch_formatter (line 98) | def patch_formatter(formatter, xdates):
  function getlocator (line 114) | def getlocator(xdates, numticks=5, tz=None):

FILE: backtrader/plot/locator.py
  function _idx2dt (line 46) | def _idx2dt(idx, dates, tz):
  class RRuleLocator (line 61) | class RRuleLocator(RRLocator):
    method __init__ (line 63) | def __init__(self, dates, o, tz=None):
    method datalim_to_dt (line 67) | def datalim_to_dt(self):
    method viewlim_to_dt (line 78) | def viewlim_to_dt(self):
    method tick_values (line 89) | def tick_values(self, vmin, vmax):
  class AutoDateLocator (line 95) | class AutoDateLocator(ADLocator):
    method __init__ (line 97) | def __init__(self, dates, *args, **kwargs):
    method datalim_to_dt (line 101) | def datalim_to_dt(self):
    method viewlim_to_dt (line 112) | def viewlim_to_dt(self):
    method tick_values (line 123) | def tick_values(self, vmin, vmax):
    method get_locator (line 128) | def get_locator(self, dmin, dmax):
  class AutoDateFormatter (line 242) | class AutoDateFormatter(ADFormatter):
    method __init__ (line 243) | def __init__(self, dates, locator, tz=None, defaultfmt='%Y-%m-%d'):
    method __call__ (line 247) | def __call__(self, x, pos=None):

FILE: backtrader/plot/multicursor.py
  class Widget (line 65) | class Widget(object):
    method set_active (line 73) | def set_active(self, active):
    method get_active (line 78) | def get_active(self):
    method ignore (line 87) | def ignore(self, event):
  class MultiCursor (line 95) | class MultiCursor(Widget):
    method __init__ (line 124) | def __init__(self, canvas, axes, useblit=True,
    method connect (line 173) | def connect(self):
    method disconnect (line 179) | def disconnect(self):
    method clear (line 184) | def clear(self, event):
    method onmove (line 194) | def onmove(self, event):
    method _update (line 223) | def _update(self, event):
  class MultiCursor2 (line 240) | class MultiCursor2(Widget):
    method __init__ (line 261) | def __init__(self, canvas, axes, useblit=True, horizOn=False, vertOn=T...
    method connect (line 298) | def connect(self):
    method disconnect (line 304) | def disconnect(self):
    method clear (line 309) | def clear(self, event):
    method onmove (line 319) | def onmove(self, event):
    method _update (line 342) | def _update(self, event):

FILE: backtrader/plot/plot.py
  class PInfo (line 50) | class PInfo(object):
    method __init__ (line 51) | def __init__(self, sch):
    method newfig (line 71) | def newfig(self, figid, numfig, mpyplot):
    method nextcolor (line 80) | def nextcolor(self, ax):
    method color (line 84) | def color(self, ax):
    method zordernext (line 87) | def zordernext(self, ax):
    method zordercur (line 93) | def zordercur(self, ax):
  class Plot_OldSync (line 97) | class Plot_OldSync(with_metaclass(MetaParams, object)):
    method __init__ (line 100) | def __init__(self, **kwargs):
    method drawtag (line 107) | def drawtag(self, ax, x, y, facecolor, edgecolor, alpha=0.9, **kwargs):
    method plot (line 119) | def plot(self, strategy, figid=0, numfigs=1, iplot=True,
    method setlocators (line 276) | def setlocators(self, ax):
    method calcrows (line 317) | def calcrows(self, strategy):
    method newaxis (line 361) | def newaxis(self, obj, rowspan):
    method plotind (line 382) | def plotind(self, iref, ind,
    method plotvolume (line 578) | def plotvolume(self, data, opens, highs, lows, closes, volumes, label):
    method plotdata (line 642) | def plotdata(self, data, indicators):
    method show (line 820) | def show(self):
    method savefig (line 823) | def savefig(self, fig, filename, width=16, height=9, dpi=300, tight=Tr...
    method sortdataindicators (line 828) | def sortdataindicators(self, strategy):

FILE: backtrader/plot/scheme.py
  class PlotScheme (line 77) | class PlotScheme(object):
    method __init__ (line 78) | def __init__(self):
    method color (line 187) | def color(self, idx):

FILE: backtrader/plot/utils.py
  function tag_box_style (line 30) | def tag_box_style(x0, y0, width, height, mutation_size, mutation_aspect=1):
  function shade_color (line 66) | def shade_color(color, percent):

FILE: backtrader/position.py
  class Position (line 28) | class Position(object):
    method __str__ (line 41) | def __str__(self):
    method __init__ (line 53) | def __init__(self, size=0, price=0.0):
    method fix (line 68) | def fix(self, size, price):
    method set (line 74) | def set(self, size, price):
    method __len__ (line 110) | def __len__(self):
    method __bool__ (line 113) | def __bool__(self):
    method clone (line 118) | def clone(self):
    method pseudoupdate (line 121) | def pseudoupdate(self, size, price):
    method update (line 124) | def update(self, size, price, dt=None):

FILE: backtrader/resamplerfilter.py
  class DTFaker (line 33) | class DTFaker(object):
    method __init__ (line 47) | def __init__(self, data, forcedata=None):
    method __len__ (line 64) | def __len__(self):
    method __call__ (line 67) | def __call__(self, idx=0):
    method datetime (line 70) | def datetime(self, idx=0):
    method date (line 73) | def date(self, idx=0):
    method time (line 76) | def time(self, idx=0):
    method _calendar (line 80) | def _calendar(self):
    method __getitem__ (line 83) | def __getitem__(self, idx):
    method num2date (line 86) | def num2date(self, *args, **kwargs):
    method date2num (line 89) | def date2num(self, *args, **kwargs):
    method _getnexteos (line 92) | def _getnexteos(self):
  class _BaseResampler (line 96) | class _BaseResampler(with_metaclass(metabase.MetaParams, object)):
    method __init__ (line 111) | def __init__(self, data):
    method _latedata (line 134) | def _latedata(self, data):
    method _checkbarover (line 142) | def _checkbarover(self, data, fromcheck=False, forcedata=None):
    method _barover (line 159) | def _barover(self, data):
    method _eosset (line 181) | def _eosset(self):
    method _eoscheck (line 186) | def _eoscheck(self, data, seteos=True, exact=False):
    method _barover_days (line 214) | def _barover_days(self, data):
    method _barover_weeks (line 217) | def _barover_weeks(self, data):
    method _barover_months (line 229) | def _barover_months(self, data):
    method _barover_years (line 238) | def _barover_years(self, data):
    method _gettmpoint (line 242) | def _gettmpoint(self, tm):
    method _barover_subdays (line 266) | def _barover_subdays(self, data):
    method check (line 299) | def check(self, data, _forcedata=None):
    method _dataonedge (line 312) | def _dataonedge(self, data):
    method _calcadjtime (line 362) | def _calcadjtime(self, greater=False):
    method _adjusttime (line 418) | def _adjusttime(self, greater=False, forcedata=None):
  class Resampler (line 435) | class Resampler(_BaseResampler):
    method last (line 478) | def last(self, data):
    method __call__ (line 495) | def __call__(self, data, fromcheck=False, forcedata=None):
  class Replayer (line 563) | class Replayer(_BaseResampler):
    method __call__ (line 615) | def __call__(self, data, fromcheck=False, forcedata=None):
  class ResamplerTicks (line 703) | class ResamplerTicks(Resampler):
  class ResamplerSeconds (line 707) | class ResamplerSeconds(Resampler):
  class ResamplerMinutes (line 711) | class ResamplerMinutes(Resampler):
  class ResamplerDaily (line 715) | class ResamplerDaily(Resampler):
  class ResamplerWeekly (line 719) | class ResamplerWeekly(Resampler):
  class ResamplerMonthly (line 723) | class ResamplerMonthly(Resampler):
  class ResamplerYearly (line 727) | class ResamplerYearly(Resampler):
  class ReplayerTicks (line 731) | class ReplayerTicks(Replayer):
  class ReplayerSeconds (line 735) | class ReplayerSeconds(Replayer):
  class ReplayerMinutes (line 739) | class ReplayerMinutes(Replayer):
  class ReplayerDaily (line 743) | class ReplayerDaily(Replayer):
  class ReplayerWeekly (line 747) | class ReplayerWeekly(Replayer):
  class ReplayerMonthly (line 751) | class ReplayerMonthly(Replayer):

FILE: backtrader/signal.py
  class Signal (line 56) | class Signal(bt.Indicator):
    method __init__ (line 61) | def __init__(self):

FILE: backtrader/sizer.py
  class Sizer (line 29) | class Sizer(with_metaclass(MetaParams, object)):
    method getsizing (line 50) | def getsizing(self, data, isbuy):
    method _getsizing (line 54) | def _getsizing(self, comminfo, cash, data, isbuy):
    method set (line 79) | def set(self, strategy, broker):

FILE: backtrader/sizers/fixedsize.py
  class FixedSize (line 27) | class FixedSize(bt.Sizer):
    method _getsizing (line 43) | def _getsizing(self, comminfo, cash, data, isbuy):
    method setsizing (line 49) | def setsizing(self, stake):
  class FixedReverser (line 59) | class FixedReverser(bt.Sizer):
    method _getsizing (line 72) | def _getsizing(self, comminfo, cash, data, isbuy):
  class FixedSizeTarget (line 78) | class FixedSizeTarget(bt.Sizer):
    method _getsizing (line 95) | def _getsizing(self, comminfo, cash, data, isbuy):
    method setsizing (line 102) | def setsizing(self, stake):

FILE: backtrader/sizers/percents_sizer.py
  class PercentSizer (line 29) | class PercentSizer(bt.Sizer):
    method __init__ (line 41) | def __init__(self):
    method _getsizing (line 44) | def _getsizing(self, comminfo, cash, data, isbuy):
  class AllInSizer (line 57) | class AllInSizer(PercentSizer):
  class PercentSizerInt (line 68) | class PercentSizerInt(PercentSizer):
  class AllInSizerInt (line 81) | class AllInSizerInt(PercentSizerInt):

FILE: backtrader/store.py
  class MetaSingleton (line 30) | class MetaSingleton(MetaParams):
    method __init__ (line 32) | def __init__(cls, name, bases, dct):
    method __call__ (line 36) | def __call__(cls, *args, **kwargs):
  class Store (line 44) | class Store(with_metaclass(MetaSingleton, object)):
    method getdata (line 51) | def getdata(self, *args, **kwargs):
    method getbroker (line 58) | def getbroker(cls, *args, **kwargs):
    method start (line 67) | def start(self, data=None, broker=None):
    method stop (line 85) | def stop(self):
    method put_notification (line 88) | def put_notification(self, msg, *args, **kwargs):
    method get_notifications (line 91) | def get_notifications(self):

FILE: backtrader/stores/ibstore.py
  function _ts2dt (line 44) | def _ts2dt(tstamp=None):
  class RTVolume (line 54) | class RTVolume(object):
    method __init__ (line 69) | def __init__(self, rtvol='', price=None, tmoffset=None):
  class MetaSingleton (line 85) | class MetaSingleton(MetaParams):
    method __init__ (line 87) | def __init__(cls, name, bases, dct):
    method __call__ (line 91) | def __call__(cls, *args, **kwargs):
  function ibregister (line 100) | def ibregister(f):
  class IBStore (line 105) | class IBStore(with_metaclass(MetaSingleton, object)):
    method getdata (line 190) | def getdata(cls, *args, **kwargs):
    method getbroker (line 195) | def getbroker(cls, *args, **kwargs):
    method __init__ (line 199) | def __init__(self):
    method start (line 300) | def start(self, data=None, broker=None):
    method stop (line 316) | def stop(self):
    method logmsg (line 326) | def logmsg(self, *args):
    method watcher (line 331) | def watcher(self, msg):
    method connected (line 337) | def connected(self):
    method reconnect (line 349) | def reconnect(self, fromstart=False, resub=False):
    method startdatas (line 400) | def startdatas(self):
    method stopdatas (line 411) | def stopdatas(self):
    method get_notifications (line 426) | def get_notifications(self):
    method error (line 441) | def error(self, msg):
    method connectionClosed (line 541) | def connectionClosed(self, msg):
    method managedAccounts (line 548) | def managedAccounts(self, msg):
    method reqCurrentTime (line 556) | def reqCurrentTime(self):
    method currentTime (line 560) | def currentTime(self, msg):
    method timeoffset (line 569) | def timeoffset(self):
    method nextTickerId (line 573) | def nextTickerId(self):
    method nextValidId (line 578) | def nextValidId(self, msg):
    method nextOrderId (line 582) | def nextOrderId(self):
    method reuseQueue (line 587) | def reuseQueue(self, tickerId):
    method getTickerQueue (line 602) | def getTickerQueue(self, start=False):
    method cancelQueue (line 617) | def cancelQueue(self, q, sendnone=False):
    method validQueue (line 628) | def validQueue(self, q):
    method getContractDetails (line 632) | def getContractDetails(self, contract, maxcount=None):
    method reqContractDetails (line 648) | def reqContractDetails(self, contract):
    method contractDetailsEnd (line 655) | def contractDetailsEnd(self, msg):
    method contractDetails (line 660) | def contractDetails(self, msg):
    method reqHistoricalDataEx (line 664) | def reqHistoricalDataEx(self, contract, enddate, begindate,
    method reqHistoricalData (line 761) | def reqHistoricalData(self, contract, enddate, duration, barsize,
    method cancelHistoricalData (line 795) | def cancelHistoricalData(self, q):
    method reqRealTimeBars (line 805) | def reqRealTimeBars(self, contract, useRTH=False, duration=5):
    method cancelRealTimeBars (line 829) | def cancelRealTimeBars(self, q):
    method reqMktData (line 842) | def reqMktData(self, contract, what=None):
    method cancelMktData (line 866) | def cancelMktData(self, q):
    method tickString (line 880) | def tickString(self, msg):
    method tickPrice (line 893) | def tickPrice(self, msg):
    method realtimeBar (line 925) | def realtimeBar(self, msg):
    method historicalData (line 936) | def historicalData(self, msg):
    method getdurations (line 1133) | def getdurations(self,  timeframe, compression):
    method getmaxduration (line 1140) | def getmaxduration(self, timeframe, compression):
    method tfcomp_to_size (line 1149) | def tfcomp_to_size(self, timeframe, compression):
    method dt_plus_duration (line 1175) | def dt_plus_duration(self, dt, duration):
    method calcdurations (line 1197) | def calcdurations(self, dtbegin, dtend):
    method calcduration (line 1214) | def calcduration(self, dtbegin, dtend):
    method histduration (line 1219) | def histduration(self, dt1, dt2):
    method makecontract (line 1275) | def makecontract(self, symbol, sectype, exch, curr,
    method cancelOrder (line 1294) | def cancelOrder(self, orderid):
    method placeOrder (line 1298) | def placeOrder(self, orderid, contract, order):
    method openOrder (line 1303) | def openOrder(self, msg):
    method execDetails (line 1308) | def execDetails(self, msg):
    method orderStatus (line 1313) | def orderStatus(self, msg):
    method commissionReport (line 1318) | def commissionReport(self, msg):
    method reqPositions (line 1322) | def reqPositions(self):
    method position (line 1327) | def position(self, msg):
    method reqAccountUpdates (line 1331) | def reqAccountUpdates(self, subscribe=True, account=None):
    method accountDownloadEnd (line 1344) | def accountDownloadEnd(self, msg):
    method updatePortfolio (line 1356) | def updatePortfolio(self, msg):
    method getposition (line 1377) | def getposition(self, contract, clone=False):
    method updateAccountValue (line 1388) | def updateAccountValue(self, msg):
    method get_acc_values (line 1405) | def get_acc_values(self, account=None):
    method get_acc_value (line 1442) | def get_acc_value(self, account=None):
    method get_acc_cash (line 1479) | def get_acc_cash(self, account=None):

FILE: backtrader/stores/oandastore.py
  class OandaRequestError (line 41) | class OandaRequestError(oandapy.OandaError):
    method __init__ (line 42) | def __init__(self):
  class OandaStreamError (line 47) | class OandaStreamError(oandapy.OandaError):
    method __init__ (line 48) | def __init__(self, content=''):
  class OandaTimeFrameError (line 53) | class OandaTimeFrameError(oandapy.OandaError):
    method __init__ (line 54) | def __init__(self, content):
  class OandaNetworkError (line 59) | class OandaNetworkError(oandapy.OandaError):
    method __init__ (line 60) | def __init__(self):
  class API (line 65) | class API(oandapy.API):
    method request (line 66) | def request(self, endpoint, method='GET', params=None):
  class Streamer (line 99) | class Streamer(oandapy.Streamer):
    method __init__ (line 100) | def __init__(self, q, headers=None, *args, **kwargs):
    method run (line 109) | def run(self, endpoint, params=None):
    method on_success (line 152) | def on_success(self, data):
    method on_error (line 158) | def on_error(self, data):
  class MetaSingleton (line 163) | class MetaSingleton(MetaParams):
    method __init__ (line 165) | def __init__(cls, name, bases, dct):
    method __call__ (line 169) | def __call__(cls, *args, **kwargs):
  class OandaStore (line 177) | class OandaStore(with_metaclass(MetaSingleton, object)):
    method getdata (line 207) | def getdata(cls, *args, **kwargs):
    method getbroker (line 212) | def getbroker(cls, *args, **kwargs):
    method __init__ (line 216) | def __init__(self):
    method start (line 238) | def start(self, data=None, broker=None):
    method stop (line 257) | def stop(self):
    method put_notification (line 264) | def put_notification(self, msg, *args, **kwargs):
    method get_notifications (line 267) | def get_notifications(self):
    method get_positions (line 297) | def get_positions(self):
    method get_granularity (line 306) | def get_granularity(self, timeframe, compression):
    method get_instrument (line 309) | def get_instrument(self, dataname):
    method streaming_events (line 319) | def streaming_events(self, tmout=None):
    method _t_streaming_listener (line 332) | def _t_streaming_listener(self, q, tmout=None):
    method _t_streaming_events (line 337) | def _t_streaming_events(self, q, tmout=None):
    method candles (line 348) | def candles(self, dataname, dtbegin, dtend, timeframe, compression,
    method _t_candles (line 359) | def _t_candles(self, dataname, dtbegin, dtend, timeframe, compression,
    method streaming_prices (line 391) | def streaming_prices(self, dataname, tmout=None):
    method _t_streaming_prices (line 399) | def _t_streaming_prices(self, dataname, q, tmout):
    method get_cash (line 409) | def get_cash(self):
    method get_value (line 412) | def get_value(self):
    method broker_threads (line 422) | def broker_threads(self):
    method _t_account (line 442) | def _t_account(self):
    method order_create (line 465) | def order_create(self, order, stopside=None, takeside=None, **kwargs):
    method _t_order_create (line 502) | def _t_order_create(self):
    method order_cancel (line 549) | def order_cancel(self, order):
    method _t_order_cancel (line 553) | def _t_order_cancel(self):
    method _transaction (line 572) | def _transaction(self, trans):
    method _process_transaction (line 631) | def _process_transaction(self, oid, trans):

FILE: backtrader/stores/vchartfile.py
  class VChartFile (line 29) | class VChartFile(bt.Store):
    method __init__ (line 44) | def __init__(self):
    method _find_vchart (line 50) | def _find_vchart():
    method get_datapath (line 86) | def get_datapath(self):

FILE: backtrader/stores/vcstore.py
  class _SymInfo (line 41) | class _SymInfo(object):
    method __init__ (line 46) | def __init__(self, syminfo):
  function PumpEvents (line 56) | def PumpEvents(timeout=-1, hevt=None, cb=None):
  class RTEventSink (line 148) | class RTEventSink(object):
    method __init__ (line 149) | def __init__(self, store):
    method OnNewTicks (line 154) | def OnNewTicks(self, ArrayTicks):
    method OnServerShutDown (line 157) | def OnServerShutDown(self):
    method OnInternalEvent (line 160) | def OnInternalEvent(self, p1, p2, p3):
  class MetaSingleton (line 173) | class MetaSingleton(MetaParams):
    method __init__ (line 175) | def __init__(cls, name, bases, dct):
    method __call__ (line 179) | def __call__(cls, *args, **kwargs):
  class VCStore (line 187) | class VCStore(with_metaclass(MetaSingleton, object)):
    method getdata (line 215) | def getdata(cls, *args, **kwargs):
    method getbroker (line 220) | def getbroker(cls, *args, **kwargs):
    method find_vchart (line 242) | def find_vchart(self):
    method _load_comtypes (line 288) | def _load_comtypes(self):
    method __init__ (line 303) | def __init__(self):
    method put_notification (line 373) | def put_notification(self, msg, *args, **kwargs):
    method get_notifications (line 376) | def get_notifications(self):
    method start (line 381) | def start(self, data=None, broker=None):
    method stop (line 396) | def stop(self):
    method connected (line 399) | def connected(self):
    method _start_vcrt (line 402) | def _start_vcrt(self):
    method _vcrt_connection (line 411) | def _vcrt_connection(self, status):
    method _tf2ct (line 428) | def _tf2ct(self, timeframe, compression):
    method _ticking (line 433) | def _ticking(self, timeframe):
    method _getq (line 438) | def _getq(self, data):
    method _delq (line 444) | def _delq(self, q):
    method _rtdata (line 448) | def _rtdata(self, data, symbol):
    method _t_rtdata (line 455) | def _t_rtdata(self, data, symbol):
    method _symboldata (line 465) | def _symboldata(self, symbol):
    method _canceldirectdata (line 479) | def _canceldirectdata(self, q):
    method _directdata (line 482) | def _directdata(self, data,
    method _t_directdata (line 499) | def _t_directdata(self, data,
    method _t_broker (line 539) | def _t_broker(self, broker):

FILE: backtrader/strategies/sma_crossover.py
  class MA_CrossOver (line 29) | class MA_CrossOver(bt.Strategy):
    method __init__ (line 62) | def __init__(self):
    method next (line 68) | def next(self):

FILE: backtrader/strategy.py
  class MetaStrategy (line 43) | class MetaStrategy(StrategyBase.__class__):
    method __new__ (line 46) | def __new__(meta, name, bases, dct):
    method __init__ (line 57) | def __init__(cls, name, bases, dct):
    method donew (line 68) | def donew(cls, *args, **kwargs):
    method dopreinit (line 77) | def dopreinit(cls, _obj, *args, **kwargs):
    method dopostinit (line 98) | def dopostinit(cls, _obj, *args, **kwargs):
  class Strategy (line 107) | class Strategy(with_metaclass(MetaStrategy, StrategyBase)):
    method qbuffer (line 120) | def qbuffer(self, savemem=0, replaying=False):
    method _periodset (line 155) | def _periodset(self):
    method _addwriter (line 217) | def _addwriter(self, writer):
    method _addindicator (line 225) | def _addindicator(self, indcls, *indargs, **indkwargs):
    method _addanalyzer_slave (line 228) | def _addanalyzer_slave(self, ancls, *anargs, **ankwargs):
    method _getanalyzer_slave (line 240) | def _getanalyzer_slave(self, idx):
    method _addanalyzer (line 243) | def _addanalyzer(self, ancls, *anargs, **ankwargs):
    method _addobserver (line 250) | def _addobserver(self, multi, obscls, *obsargs, **obskwargs):
    method _getminperstatus (line 268) | def _getminperstatus(self):
    method prenext_open (line 274) | def prenext_open(self):
    method nextstart_open (line 277) | def nextstart_open(self):
    method next_open (line 280) | def next_open(self):
    method _oncepost_open (line 283) | def _oncepost_open(self):
    method _oncepost (line 292) | def _oncepost(self, dt):
    method _clk_update (line 320) | def _clk_update(self):
    method _next_open (line 337) | def _next_open(self):
    method _next (line 346) | def _next(self):
    method _next_observers (line 355) | def _next_observers(self, minperstatus, once=False):
    method _next_analyzers (line 381) | def _next_analyzers(self, minperstatus, once=False):
    method _settz (line 390) | def _settz(self, tz):
    method _start (line 393) | def _start(self):
    method start (line 415) | def start(self):
    method getwriterheaders (line 419) | def getwriterheaders(self):
    method getwritervalues (line 437) | def getwritervalues(self):
    method getwriterinfo (line 452) | def getwriterinfo(self):
    method _stop (line 482) | def _stop(self):
    method stop (line 491) | def stop(self):
    method set_tradehistory (line 495) | def set_tradehistory(self, onoff=True):
    method clear (line 498) | def clear(self):
    method _addnotification (line 503) | def _addnotification(self, order, quicknotify=False):
    method _notify (line 577) | def _notify(self, qorders=[], qtrades=[]):
    method add_timer (line 615) | def add_timer(self, when,
    method notify_timer (line 715) | def notify_timer(self, timer, when, *args, **kwargs):
    method notify_cashvalue (line 726) | def notify_cashvalue(self, cash, value):
    method notify_fund (line 732) | def notify_fund(self, cash, value, fundvalue, shares):
    method notify_order (line 738) | def notify_order(self, order):
    method notify_trade (line 744) | def notify_trade(self, trade):
    method notify_store (line 750) | def notify_store(self, msg, *args, **kwargs):
    method notify_data (line 754) | def notify_data(self, data, status, *args, **kwargs):
    method getdatanames (line 758) | def getdatanames(self):
    method getdatabyname (line 764) | def getdatabyname(self, name):
    method cancel (line 770) | def cancel(self, order):
    method buy (line 774) | def buy(self, data=None,
    method sell (line 943) | def sell(self, data=None,
    method close (line 973) | def close(self, data=None, size=None, **kwargs):
    method buy_bracket (line 1001) | def buy_bracket(self, data=None, size=None, price=None, plimit=None,
    method sell_bracket (line 1175) | def sell_bracket(self, data=None,
    method order_target_size (line 1247) | def order_target_size(self, data=None, target=0, **kwargs):
    method order_target_value (line 1283) | def order_target_value(self, data=None, target=0.0, price=None, **kwar...
    method order_target_percent (line 1330) | def order_target_percent(self, data=None, target=0.0, **kwargs):
    method getposition (line 1378) | def getposition(self, data=None, broker=None):
    method getpositionbyname (line 1392) | def getpositionbyname(self, name=None, broker=None):
    method getpositions (line 1406) | def getpositions(self, broker=None):
    method getpositionsbyname (line 1419) | def getpositionsbyname(self, broker=None):
    method _addsizer (line 1438) | def _addsizer(self, sizer, *args, **kwargs):
    method setsizer (line 1444) | def setsizer(self, sizer):
    method getsizer (line 1452) | def getsizer(self):
    method getsizing (line 1463) | def getsizing(self, data=None, isbuy=True):
  class MetaSigStrategy (line 1472) | class MetaSigStrategy(Strategy.__class__):
    method __new__ (line 1474) | def __new__(meta, name, bases, dct):
    method dopreinit (line 1485) | def dopreinit(cls, _obj, *args, **kwargs):
    method dopostinit (line 1505) | def dopostinit(cls, _obj, *args, **kwargs):
  class SignalStrategy (line 1524) | class SignalStrategy(with_metaclass(MetaSigStrategy, Strategy)):
    method _start (line 1612) | def _start(self):
    method signal_add (line 1616) | def signal_add(self, sigtype, signal):
    method _notify (line 1619) | def _notify(self, qorders=[], qtrades=[]):
    method _next_catch (line 1630) | def _next_catch(self):
    method _next_signal (line 1635) | def _next_signal(self):

FILE: backtrader/studies/contrib/fractal.py
  class Fractal (line 30) | class Fractal(bt.ind.PeriodN):
    method next (line 52) | def next(self):

FILE: backtrader/talib.py
  class _MetaTALibIndicator (line 65) | class _MetaTALibIndicator(bt.Indicator.__class__):
    method dopostinit (line 71) | def dopostinit(cls, _obj, *args, **kwargs):
  class _TALibIndicator (line 92) | class _TALibIndicator(with_metaclass(_MetaTALibIndicator, bt.Indicator)):
    method _subclass (line 97) | def _subclass(cls, name):
    method oncestart (line 187) | def oncestart(self, start, end):
    method once (line 190) | def once(self, start, end):
    method next (line 212) | def next(self):

FILE: backtrader/timer.py
  class Timer (line 42) | class Timer(with_metaclass(MetaParams, object)):
    method __init__ (line 61) | def __init__(self, *args, **kwargs):
    method start (line 65) | def start(self, data):
    method _reset_when (line 90) | def _reset_when(self, ddate=datetime.min):
    method _check_month (line 96) | def _check_month(self, ddate):
    method _check_week (line 123) | def _check_week(self, ddate=date.min):
    method check (line 150) | def check(self, dt):

FILE: backtrader/trade.py
  class TradeHistory (line 31) | class TradeHistory(AutoOrderedDict):
    method __init__ (line 58) | def __init__(self,
    method __reduce__ (line 74) | def __reduce__(self):
    method doupdate (line 79) | def doupdate(self, order, size, price, commission):
    method datetime (line 89) | def datetime(self, tz=None, naive=True):
  class Trade (line 94) | class Trade(object):
    method __str__ (line 152) | def __str__(self):
    method __init__ (line 165) | def __init__(self, data=None, tradeid=0, historyon=False,
    method __len__ (line 194) | def __len__(self):
    method __bool__ (line 198) | def __bool__(self):
    method getdataname (line 204) | def getdataname(self):
    method open_datetime (line 208) | def open_datetime(self, tz=None, naive=True):
    method close_datetime (line 214) | def close_datetime(self, tz=None, naive=True):
    method update (line 220) | def update(self, order, size, price, value, commission, pnl,

FILE: backtrader/tradingcal.py
  class TradingCalendarBase (line 47) | class TradingCalendarBase(with_metaclass(MetaParams, object)):
    method _nextday (line 48) | def _nextday(self, day):
    method schedule (line 57) | def schedule(self, day):
    method nextday (line 64) | def nextday(self, day):
    method nextday_week (line 71) | def nextday_week(self, day):
    method last_weekday (line 78) | def last_weekday(self, day):
    method last_monthday (line 87) | def last_monthday(self, day):
    method last_yearday (line 96) | def last_yearday(self, day):
  class TradingCalendar (line 106) | class TradingCalendar(TradingCalendarBase):
    method __init__ (line 146) | def __init__(self):
    method _nextday (line 149) | def _nextday(self, day):
    method schedule (line 164) | def schedule(self, day, tz=None):
  class PandasMarketCalendar (line 197) | class PandasMarketCalendar(TradingCalendarBase):
    method __init__ (line 229) | def __init__(self):
    method _nextday (line 241) | def _nextday(self, day):
    method schedule (line 259) | def schedule(self, day, tz=None):

FILE: backtrader/utils/autodict.py
  function Tree (line 29) | def Tree():
  class AutoDictList (line 33) | class AutoDictList(dict):
    method __missing__ (line 34) | def __missing__(self, key):
  class DotDict (line 39) | class DotDict(dict):
    method __getattr__ (line 41) | def __getattr__(self, key):
  class AutoDict (line 47) | class AutoDict(dict):
    method _close (line 50) | def _close(self):
    method _open (line 56) | def _open(self):
    method __missing__ (line 59) | def __missing__(self, key):
    method __getattr__ (line 66) | def __getattr__(self, key):
    method __setattr__ (line 72) | def __setattr__(self, key, value):
  class AutoOrderedDict (line 80) | class AutoOrderedDict(OrderedDict):
    method _close (line 83) | def _close(self):
    method _open (line 89) | def _open(self):
    method __missing__ (line 92) | def __missing__(self, key):
    method __getattr__ (line 100) | def __getattr__(self, key):
    method __setattr__ (line 106) | def __setattr__(self, key, value):
    method __iadd__ (line 114) | def __iadd__(self, other):
    method __isub__ (line 120) | def __isub__(self, other):
    method __imul__ (line 126) | def __imul__(self, other):
    method __idiv__ (line 132) | def __idiv__(self, other):
    method __itruediv__ (line 138) | def __itruediv__(self, other):
    method lvalues (line 144) | def lvalues(self):

FILE: backtrader/utils/dateintern.py
  function tzparse (line 48) | def tzparse(tz):
  function Localizer (line 73) | def Localizer(tz):
  class _UTC (line 87) | class _UTC(datetime.tzinfo):
    method utcoffset (line 90) | def utcoffset(self, dt):
    method tzname (line 93) | def tzname(self, dt):
    method dst (line 96) | def dst(self, dt):
    method localize (line 99) | def localize(self, dt):
  class _LocalTimezone (line 103) | class _LocalTimezone(datetime.tzinfo):
    method utcoffset (line 105) | def utcoffset(self, dt):
    method dst (line 111) | def dst(self, dt):
    method tzname (line 117) | def tzname(self, dt):
    method _isdst (line 120) | def _isdst(self, dt):
    method localize (line 132) | def localize(self, dt):
  function num2date (line 149) | def num2date(x, tz=None, naive=True):
  function num2dt (line 194) | def num2dt(num, tz=None, naive=True):
  function num2time (line 198) | def num2time(num, tz=None, naive=True):
  function date2num (line 202) | def date2num(dt, tz=None):
  function time2num (line 230) | def time2num(tm):

FILE: backtrader/utils/flushfile.py
  class flushfile (line 27) | class flushfile(object):
    method __init__ (line 29) | def __init__(self, f):
    method write (line 32) | def write(self, x):
    method flush (line 36) | def flush(self):
  class StdOutDevNull (line 44) | class StdOutDevNull(object):
    method __init__ (line 46) | def __init__(self):
    method write (line 50) | def write(self, x):
    method flush (line 53) | def flush(self):
    method stop (line 56) | def stop(self):

FILE: backtrader/utils/ordereddefaultdict.py
  class OrderedDefaultdict (line 31) | class OrderedDefaultdict(OrderedDict):
    method __init__ (line 32) | def __init__(self, *args, **kwargs):
    method __missing__ (line 42) | def __missing__(self, key):
    method __reduce__ (line 48) | def __reduce__(self):  # optional, for pickle support

FILE: backtrader/utils/py3.py
  function iterkeys (line 61) | def iterkeys(d): return d.iterkeys()
  function itervalues (line 63) | def itervalues(d): return d.itervalues()
  function iteritems (line 65) | def iteritems(d): return d.iteritems()
  function keys (line 67) | def keys(d): return d.keys()
  function values (line 69) | def values(d): return d.values()
  function items (line 71) | def items(d): return d.items()
  function cmp (line 96) | def cmp(a, b): return (a > b) - (a < b)
  function bytes (line 98) | def bytes(x): return x.encode('utf-8')
  function bstr (line 100) | def bstr(x): return str(x)
  function iterkeys (line 108) | def iterkeys(d): return iter(d.keys())
  function itervalues (line 110) | def itervalues(d): return iter(d.values())
  function iteritems (line 112) | def iteritems(d): return iter(d.items())
  function keys (line 114) | def keys(d): return list(d.keys())
  function values (line 116) | def values(d): return list(d.values())
  function items (line 118) | def items(d): return list(d.items())
  function with_metaclass (line 124) | def with_metaclass(meta, *bases):

FILE: backtrader/writer.py
  class WriterBase (line 39) | class WriterBase(with_metaclass(bt.MetaParams, object)):
  class WriterFile (line 43) | class WriterFile(WriterBase):
    method __init__ (line 108) | def __init__(self):
    method _start_output (line 113) | def _start_output(self):
    method start (line 126) | def start(self):
    method stop (line 133) | def stop(self):
    method next (line 137) | def next(self):
    method addheaders (line 142) | def addheaders(self, headers):
    method addvalues (line 146) | def addvalues(self, values):
    method writeiterable (line 152) | def writeiterable(self, iterable, func=None, counter=''):
    method writeline (line 162) | def writeline(self, line):
    method writelines (line 165) | def writelines(self, lines):
    method writelineseparator (line 169) | def writelineseparator(self, level=0):
    method writedict (line 177) | def writedict(self, dct, level=0, recurse=False):
  class WriterStringIO (line 221) | class WriterStringIO(WriterFile):
    method __init__ (line 224) | def __init__(self):
    method _start_output (line 227) | def _start_output(self):
    method stop (line 231) | def stop(self):

FILE: contrib/samples/pair-trading/pair-trading.py
  class PairTradingStrategy (line 20) | class PairTradingStrategy(bt.Strategy):
    method log (line 35) | def log(self, txt, dt=None):
    method notify_order (line 41) | def notify_order(self, order):
    method __init__ (line 60) | def __init__(self):
    method next (line 82) | def next(self):
    method stop (line 156) | def stop(self):
  function runstrategy (line 163) | def runstrategy():
  function parse_args (line 212) | def parse_args():

FILE: contrib/utils/influxdb-import.py
  class InfluxDBTool (line 15) | class InfluxDBTool(object):
    method __init__ (line 16) | def __init__(self):
    method write_dataframe_to_idb (line 29) | def write_dataframe_to_idb(self, ticker):
    method get_tickers_from_file (line 51) | def get_tickers_from_file(self, filename):

FILE: contrib/utils/iqfeed-to-influxdb.py
  class IQFeedTool (line 17) | class IQFeedTool(object):
    method __init__ (line 18) | def __init__(self):
    method _send_cmd (line 59) | def _send_cmd(self, cmd: str):
    method iq_query (line 63) | def iq_query(self, message: str):
    method get_historical_minute_data (line 92) | def get_historical_minute_data(self, ticker: str):
    method add_data_to_df (line 120) | def add_data_to_df(self, data: np.array):
    method get_tickers_from_file (line 144) | def get_tickers_from_file(self, filename):

FILE: samples/analyzer-annualreturn/analyzer-annualreturn.py
  class LongShortStrategy (line 35) | class LongShortStrategy(bt.Strategy):
    method start (line 49) | def start(self):
    method stop (line 52) | def stop(self):
    method log (line 55) | def log(self, txt, dt=None):
    method __init__ (line 61) | def __init__(self):
    method next (line 71) | def next(self):
    method notify_order (line 92) | def notify_order(self, order):
    method notify_trade (line 111) | def notify_trade(self, trade):
  function runstrategy (line 120) | def runstrategy():
  function parse_args (line 181) | def parse_args():

FILE: samples/bidask-to-ohlc/bidask-to-ohlc.py
  class St (line 31) | class St(bt.Strategy):
    method next (line 32) | def next(self):
  function runstrat (line 40) | def runstrat():
  function parse_args (line 70) | def parse_args():

FILE: samples/bracket/bracket.py
  class St (line 31) | class St(bt.Strategy):
    method notify_order (line 44) | def notify_order(self, order):
    method __init__ (line 56) | def __init__(self):
    method next (line 65) | def next(self):
  function runstrat (line 126) | def runstrat(args=None):
  function parse_args (line 161) | def parse_args(pargs=None):

FILE: samples/btfd/btfd.py
  class ValueUnlever (line 34) | class ValueUnlever(bt.observers.Value):
    method next (line 39) | def next(self):
  class St (line 51) | class St(bt.Strategy):
    method __init__ (line 62) | def __init__(self):
    method next (line 72) | def next(self):
    method start (line 94) | def start(self):
    method notify_order (line 104) | def notify_order(self, order):
    method notify_trade (line 118) | def notify_trade(self, trade):
  function runstrat (line 142) | def runstrat(args=None):
  function parse_args (line 183) | def parse_args(pargs=None):

FILE: samples/calendar-days/calendar-days.py
  function runstrat (line 33) | def runstrat():
  function parse_args (line 79) | def parse_args():

FILE: samples/calmar/calmar-test.py
  class St (line 31) | class St(bt.SignalStrategy):
    method __init__ (line 35) | def __init__(self):
    method next2 (line 39) | def next2(self):
  function runstrat (line 43) | def runstrat(args=None):
  function parse_args (line 83) | def parse_args(pargs=None):

FILE: samples/cheat-on-open/cheat-on-open.py
  class St (line 30) | class St(bt.Strategy):
    method __init__ (line 36) | def __init__(self):
    method notify_order (line 42) | def notify_order(self, order):
    method operate (line 52) | def operate(self, fromopen):
    method next (line 65) | def next(self):
    method next_open (line 75) | def next_open(self):
  function runstrat (line 81) | def runstrat(args=None):
  function parse_args (line 116) | def parse_args(pargs=None):

FILE: samples/commission-schemes/commission-schemes.py
  class SMACrossOver (line 32) | class SMACrossOver(bt.Strategy):
    method log (line 38) | def log(self, txt, dt=None):
    method notify_order (line 43) | def notify_order(self, order):
    method notify_trade (line 63) | def notify_trade(self, trade):
    method __init__ (line 68) | def __init__(self):
    method next (line 73) | def next(self):
  function runstrategy (line 83) | def runstrategy():
  function parse_args (line 129) | def parse_args():

FILE: samples/credit-interest/credit-interest.py
  class SMACrossOver (line 32) | class SMACrossOver(bt.Signal):
    method __init__ (line 35) | def __init__(self):
  class NoExit (line 41) | class NoExit(bt.Signal):
    method next (line 42) | def next(self):
  class St (line 46) | class St(bt.SignalStrategy):
    method notify_order (line 49) | def notify_order(self, order):
    method notify_trade (line 58) | def notify_trade(self, trade):
  function runstrat (line 64) | def runstrat(args=None):
  function parse_args (line 121) | def parse_args(pargs=None):

FILE: samples/data-bid-ask/bidask.py
  class BidAskCSV (line 31) | class BidAskCSV(btfeeds.GenericCSVData):
  class St (line 43) | class St(bt.Strategy):
    method __init__ (line 46) | def __init__(self):
    method next (line 50) | def next(self):
  function parse_args (line 60) | def parse_args():
  function runstrategy (line 85) | def runstrategy():

FILE: samples/data-filler/data-filler.py
  function runstrategy (line 37) | def runstrategy():
  function parse_args (line 95) | def parse_args():

FILE: samples/data-filler/relativevolume.py
  class RelativeVolume (line 29) | class RelativeVolume(bt.Indicator):
    method __init__ (line 38) | def __init__(self):

FILE: samples/data-multitimeframe/data-multitimeframe.py
  class SMAStrategy (line 34) | class SMAStrategy(bt.Strategy):
    method __init__ (line 40) | def __init__(self):
    method prenext (line 48) | def prenext(self):
    method nextstart (line 51) | def nextstart(self):
    method next (line 58) | def next(self):
  function runstrat (line 93) | def runstrat():
  function parse_args (line 174) | def parse_args():

FILE: samples/data-pandas/data-pandas-optix.py
  class PandasDataOptix (line 32) | class PandasDataOptix(btfeeds.PandasData):
  class StrategyOptix (line 45) | class StrategyOptix(bt.Strategy):
    method next (line 47) | def next(self):
  function runstrat (line 55) | def runstrat():
  function parse_args (line 95) | def parse_args():

FILE: samples/data-pandas/data-pandas.py
  function runstrat (line 32) | def runstrat():
  function parse_args (line 77) | def parse_args():

FILE: samples/data-replay/data-replay.py
  class SMAStrategy (line 31) | class SMAStrategy(bt.Strategy):
    method __init__ (line 37) | def __init__(self):
    method start (line 40) | def start(self):
    method prenext (line 43) | def prenext(self):
    method next (line 47) | def next(self):
  function runstrat (line 52) | def runstrat():
  function parse_args (line 96) | def parse_args():

FILE: samples/data-resample/data-resample.py
  function runstrat (line 30) | def runstrat():
  function parse_args (line 74) | def parse_args():

FILE: samples/daysteps/daysteps.py
  class St (line 29) | class St(bt.Strategy):
    method __init__ (line 32) | def __init__(self):
    method start (line 35) | def start(self):
    method next (line 52) | def next(self):
  function runstrat (line 74) | def runstrat():
  function parse_args (line 91) | def parse_args(pargs=None):

FILE: samples/future-spot/future-spot.py
  function close_changer (line 30) | def close_changer(data, *args, **kwargs):
  class BuySellArrows (line 36) | class BuySellArrows(bt.observers.BuySell):
  class St (line 41) | class St(bt.Strategy):
    method __init__ (line 42) | def __init__(self):
    method next (line 46) | def next(self):
  function runstrat (line 57) | def runstrat(args=None):
  function parse_args (line 85) | def parse_args(pargs=None):

FILE: samples/gold-vs-sp500/gold-vs-sp500.py
  class PearsonR (line 35) | class PearsonR(bt.ind.PeriodN):
    method next (line 41) | def next(self):
  class MACrossOver (line 48) | class MACrossOver(bt.Strategy):
    method __init__ (line 55) | def __init__(self):
  function runstrat (line 61) | def runstrat(args=None):
  function parse_args (line 115) | def parse_args(pargs=None):

FILE: samples/ib-cash-bid-ask/ib-cash-bid-ask.py
  class St (line 34) | class St(bt.Strategy):
    method logdata (line 35) | def logdata(self):
    method notify_data (line 52) | def notify_data(self, data, status, *args, **kwargs):
    method next (line 67) | def next(self):
  function run (line 83) | def run(args=None):

FILE: samples/ibtest/ibtest.py
  class TestStrategy (line 32) | class TestStrategy(bt.Strategy):
    method __init__ (line 51) | def __init__(self):
    method notify_data (line 66) | def notify_data(self, data, status, *args, **kwargs):
    method notify_store (line 72) | def notify_store(self, msg, *args, **kwargs):
    method notify_order (line 75) | def notify_order(self, order):
    method notify_trade (line 83) | def notify_trade(self, trade):
    method prenext (line 88) | def prenext(self):
    method next (line 91) | def next(self, frompre=False):
    method start (line 199) | def start(self):
  function runstrategy (line 211) | def runstrategy():
  function parse_args (line 342) | def parse_args():

FILE: samples/kselrsi/ksignal.py
  class TheStrategy (line 30) | class TheStrategy(bt.SignalStrategy):
    method notify_order (line 34) | def notify_order(self, order):
    method __init__ (line 44) | def __init__(self):
  function runstrat (line 62) | def runstrat(pargs=None):
  function parse_args (line 87) | def parse_args(pargs=None):

FILE: samples/lineplotter/lineplotter.py
  class St (line 30) | class St(bt.Strategy):
    method __init__ (line 35) | def __init__(self):
  function runstrat (line 45) | def runstrat(pargs=None):
  function parse_args (line 75) | def parse_args(pargs=None):

FILE: samples/lrsi/lrsi-test.py
  class St (line 31) | class St(bt.Strategy):
    method __init__ (line 35) | def __init__(self):
    method next (line 42) | def next(self):
  function runstrat (line 46) | def runstrat(args=None):
  function parse_args (line 81) | def parse_args(pargs=None):

FILE: samples/macd-settings/macd-settings.py
  class FixedPerc (line 34) | class FixedPerc(bt.Sizer):
    method _getsizing (line 45) | def _getsizing(self, comminfo, cash, data, isbuy):
  class TheStrategy (line 54) | class TheStrategy(bt.Strategy):
    method notify_order (line 85) | def notify_order(self, order):
    method __init__ (line 92) | def __init__(self):
    method start (line 108) | def start(self):
    method next (line 111) | def next(self):
  function runstrat (line 140) | def runstrat(args=None):
  function parse_args (line 206) | def parse_args(pargs=None):

FILE: samples/memory-savings/memory-savings.py
  class TestInd (line 33) | class TestInd(bt.Indicator):
    method __init__ (line 36) | def __init__(self):
  class St (line 41) | class St(bt.Strategy):
    method __init__ (line 47) | def __init__(self):
    method next (line 55) | def next(self):
    method loglendetails (line 65) | def loglendetails(self, msg):
    method stop (line 69) | def stop(self):
    method rindicator (line 101) | def rindicator(self, ind, i, deep):
  function runstrat (line 123) | def runstrat():
  function parse_args (line 137) | def parse_args():

FILE: samples/mixing-timeframes/mixing-timeframes.py
  class St (line 32) | class St(bt.Strategy):
    method __init__ (line 35) | def __init__(self):
    method next (line 45) | def next(self):
  function runstrat (line 58) | def runstrat():
  function parse_args (line 73) | def parse_args():

FILE: samples/multi-copy/multi-copy.py
  class TheStrategy (line 32) | class TheStrategy(bt.Strategy):
    method notify_order (line 55) | def notify_order(self, order):
    method __init__ (line 70) | def __init__(self):
    method start (line 87) | def start(self):
    method next (line 94) | def next(self):
  class TheStrategy2 (line 124) | class TheStrategy2(TheStrategy):
  function runstrat (line 139) | def runstrat(args=None):
  function parse_args (line 193) | def parse_args(pargs=None):

FILE: samples/multi-example/mult-values.py
  class TestSizer (line 31) | class TestSizer(bt.Sizer):
    method _getsizing (line 34) | def _getsizing(self, comminfo, cash, data, isbuy):
  class St (line 43) | class St(bt.Strategy):
    method notify_order (line 54) | def notify_order(self, order):
    method __init__ (line 73) | def __init__(self):
    method next (line 77) | def next(self):
  function runstrat (line 130) | def runstrat(args=None):
  function parse_args (line 175) | def parse_args(pargs=None):

FILE: samples/multidata-strategy/multidata-strategy-unaligned.py
  class MultiDataStrategy (line 33) | class MultiDataStrategy(bt.Strategy):
    method log (line 50) | def log(self, txt, dt=None):
    method notify_order (line 56) | def notify_order(self, order):
    method __init__ (line 75) | def __init__(self):
    method next (line 84) | def next(self):
    method stop (line 108) | def stop(self):
  function runstrategy (line 115) | def runstrategy():
  function parse_args (line 164) | def parse_args():

FILE: samples/multidata-strategy/multidata-strategy.py
  class MultiDataStrategy (line 33) | class MultiDataStrategy(bt.Strategy):
    method log (line 50) | def log(self, txt, dt=None):
    method notify_order (line 56) | def notify_order(self, order):
    method __init__ (line 75) | def __init__(self):
    method next (line 84) | def next(self):
    method stop (line 110) | def stop(self):
  function runstrategy (line 117) | def runstrategy():
  function parse_args (line 166) | def parse_args():

FILE: samples/multitrades/mtradeobserver.py
  class MTradeObserver (line 29) | class MTradeObserver(bt.observer.Observer):
    method next (line 40) | def next(self):

FILE: samples/multitrades/multitrades.py
  class MultiTradeStrategy (line 36) | class MultiTradeStrategy(bt.Strategy):
    method log (line 50) | def log(self, txt, dt=None):
    method __init__ (line 56) | def __init__(self):
    method next (line 71) | def next(self):
    method notify_order (line 94) | def notify_order(self, order):
    method notify_trade (line 113) | def notify_trade(self, trade):
  function runstrategy (line 122) | def runstrategy():
  function parse_args (line 168) | def parse_args():

FILE: samples/oandatest/oandatest.py
  class TestStrategy (line 36) | class TestStrategy(bt.Strategy):
    method __init__ (line 50) | def __init__(self):
    method notify_data (line 65) | def notify_data(self, data, status, *args, **kwargs):
    method notify_store (line 71) | def notify_store(self, msg, *args, **kwargs):
    method notify_order (line 74) | def notify_order(self, order):
    method notify_trade (line 82) | def notify_trade(self, trade):
    method prenext (line 87) | def prenext(self):
    method next (line 90) | def next(self, frompre=False):
    method start (line 179) | def start(self):
  function runstrategy (line 191) | def runstrategy():
  function parse_args (line 321) | def parse_args(pargs=None):

FILE: samples/observer-benchmark/observer-benchmark.py
  class St (line 32) | class St(bt.Strategy):
    method __init__ (line 39) | def __init__(self):
    method start (line 43) | def start(self):
    method next (line 56) | def next(self):
  function runstrat (line 95) | def runstrat(args=None):
  function parse_args (line 142) | def parse_args(pargs=None):

FILE: samples/observers/observers-default-drawdown.py
  class MyStrategy (line 36) | class MyStrategy(bt.Strategy):
    method log (line 39) | def log(self, txt, dt=None):
    method __init__ (line 46) | def __init__(self):
    method next (line 57) | def next(self):
  function runstrat (line 73) | def runstrat():

FILE: samples/observers/observers-orderobserver.py
  class MyStrategy (line 33) | class MyStrategy(bt.Strategy):
    method log (line 40) | def log(self, txt, dt=None):
    method notify_order (line 47) | def notify_order(self, order):
    method __init__ (line 74) | def __init__(self):
    method next (line 85) | def next(self):
  function runstrat (line 104) | def runstrat():

FILE: samples/observers/orderobserver.py
  class OrderObserver (line 29) | class OrderObserver(bt.observer.Observer):
    method next (line 39) | def next(self):

FILE: samples/oco/oco.py
  class St (line 31) | class St(bt.Strategy):
    method notify_order (line 46) | def notify_order(self, order):
    method __init__ (line 58) | def __init__(self):
    method next (line 72) | def next(self):
  function runstrat (line 122) | def runstrat(args=None):
  function parse_args (line 157) | def parse_args(pargs=None):

FILE: samples/optimization/optimization.py
  class OptimizeStrategy (line 35) | class OptimizeStrategy(bt.Strategy):
    method __init__ (line 42) | def __init__(self):
  function runstrat (line 51) | def runstrat():
  function parse_args (line 104) | def parse_args():

FILE: samples/order-close/close-daily.py
  class St (line 34) | class St(bt.Strategy):
    method __init__ (line 35) | def __init__(self):
    method notify_order (line 38) | def notify_order(self, order):
    method next (line 49) | def next(self):
  class SessionEndFiller (line 64) | class SessionEndFiller(with_metaclass(bt.metabase.MetaParams, object)):
    method __call__ (line 76) | def __call__(self, data):
  function runstrat (line 91) | def runstrat():
  function getdata (line 103) | def getdata(args):
  function parse_args (line 141) | def parse_args():

FILE: samples/order-close/close-minute.py
  class St (line 31) | class St(bt.Strategy):
    method __init__ (line 32) | def __init__(self):
    method notify_order (line 37) | def notify_order(self, order):
    method next (line 47) | def next(self):
  function runstrat (line 64) | def runstrat():
  function getdata (line 76) | def getdata(args):
  function parse_args (line 110) | def parse_args():

FILE: samples/order-execution/order-execution.py
  class OrderExecutionStrategy (line 36) | class OrderExecutionStrategy(bt.Strategy):
    method log (line 45) | def log(self, txt, dt=None):
    method notify_order (line 52) | def notify_order(self, order):
    method __init__ (line 79) | def __init__(self):
    method next (line 90) | def next(self):
  function runstrat (line 164) | def runstrat():
  function getdata (line 186) | def getdata(args):
  function parse_args (line 215) | def parse_args():

FILE: samples/order-history/order-history.py
  class SmaCross (line 61) | class SmaCross(bt.SignalStrategy):
    method notify_order (line 64) | def notify_order(self, order):
    method notify_trade (line 71) | def notify_trade(self, trade):
    method __init__ (line 75) | def __init__(self):
  class St (line 83) | class St(bt.Strategy):
    method notify_order (line 87) | def notify_order(self, order):
    method notify_trade (line 94) | def notify_trade(self, trade):
    method __init__ (line 98) | def __init__(self):
    method next (line 102) | def next(self):
  function runstrat (line 106) | def runstrat(args=None):
  function parse_args (line 148) | def parse_args(pargs=None):

FILE: samples/order_target/order_target.py
  class TheStrategy (line 30) | class TheStrategy(bt.Strategy):
    method notify_order (line 56) | def notify_order(self, order):
    method start (line 63) | def start(self):
    method next (line 66) | def next(self):
  function runstrat (line 115) | def runstrat(args=None):
  function parse_args (line 148) | def parse_args(pargs=None):

FILE: samples/partial-plot/partial-plot.py
  class St (line 31) | class St(bt.Strategy):
    method __init__ (line 35) | def __init__(self):
    method next (line 45) | def next(self):
  function runstrat (line 49) | def runstrat(args=None):
  function parse_args (line 86) | def parse_args(pargs=None):

FILE: samples/pinkfish-challenge/pinkfish-challenge.py
  class DayStepsCloseFilter (line 31) | class DayStepsCloseFilter(bt.with_metaclass(bt.MetaParams, object)):
    method __init__ (line 52) | def __init__(self, data):
    method __call__ (line 55) | def __call__(self, data):
    method last (line 82) | def last(self, data):
  class DayStepsReplayFilter (line 95) | class DayStepsReplayFilter(bt.with_metaclass(bt.MetaParams, object)):
    method __init__ (line 118) | def __init__(self, data):
    method __call__ (line 122) | def __call__(self, data):
  class St (line 169) | class St(bt.Strategy):
    method __init__ (line 176) | def __init__(self):
    method start (line 179) | def start(self):
    method notify_order (line 202) | def notify_order(self, order):
    method next (line 208) | def next(self):
  function runstrat (line 244) | def runstrat():
  function parse_args (line 290) | def parse_args(pargs=None):

FILE: samples/pivot-point/pivotpoint.py
  class PivotPoint1 (line 27) | class PivotPoint1(bt.Indicator):
    method __init__ (line 30) | def __init__(self):
  class PivotPoint (line 46) | class PivotPoint(bt.Indicator):
    method __init__ (line 50) | def __init__(self):

FILE: samples/pivot-point/ppsample.py
  class St (line 31) | class St(bt.Strategy):
    method __init__ (line 35) | def __init__(self):
    method next (line 39) | def next(self):
  function runstrat (line 51) | def runstrat():
  function parse_args (line 67) | def parse_args():

FILE: samples/plot-same-axis/plot-same-axis.py
  class PlotStrategy (line 33) | class PlotStrategy(bt.Strategy):
    method __init__ (line 46) | def __init__(self):
  function runstrategy (line 66) | def runstrategy():
  function parse_args (line 101) | def parse_args():

FILE: samples/psar/psar-intraday.py
  class St (line 31) | class St(bt.Strategy):
    method __init__ (line 35) | def __init__(self):
    method next (line 40) | def next(self):
  function runstrat (line 58) | def runstrat(args=None):
  function parse_args (line 98) | def parse_args(pargs=None):

FILE: samples/psar/psar.py
  class St (line 31) | class St(bt.Strategy):
    method __init__ (line 35) | def __init__(self):
    method next (line 39) | def next(self):
  function runstrat (line 46) | def runstrat(args=None):
  function parse_args (line 81) | def parse_args(pargs=None):

FILE: samples/pyfolio2/pyfoliotest.py
  class St (line 33) | class St(bt.SignalStrategy):
    method __init__ (line 42) | def __init__(self):
    method start (line 51) | def start(self):
    method next (line 65) | def next(self):
  function runstrat (line 94) | def runstrat(args=None):
  function parse_args (line 185) | def parse_args(pargs=None):

FILE: samples/pyfoliotest/pyfoliotest.py
  class St (line 32) | class St(bt.Strategy):
    method __init__ (line 38) | def __init__(self):
    method start (line 41) | def start(self):
    method next (line 54) | def next(self):
  function runstrat (line 85) | def runstrat(args=None):
  function parse_args (line 142) | def parse_args(args=None):

FILE: samples/relative-volume/relative-volume.py
  function runstrategy (line 34) | def runstrategy():
  function parse_args (line 78) | def parse_args():

FILE: samples/relative-volume/relvolbybar.py
  class RelativeVolumeByBar (line 32) | class RelativeVolumeByBar(bt.Indicator):
    method _plotlabel (line 42) | def _plotlabel(self):
    method __init__ (line 49) | def __init__(self):
    method _barisvalid (line 64) | def _barisvalid(self, tm):
    method _daycount (line 67) | def _daycount(self):
    method prenext (line 73) | def prenext(self):
    method next (line 81) | def next(self):
    method _calcbuffer (line 104) | def _calcbuffer(self):

FILE: samples/renko/renko.py
  class St (line 30) | class St(bt.Strategy):
    method __init__ (line 34) | def __init__(self):
    method next (line 38) | def next(self):
  function runstrat (line 42) | def runstrat(args=None):
  function parse_args (line 91) | def parse_args(pargs=None):

FILE: samples/resample-tickdata/resample-tickdata.py
  function runstrat (line 30) | def runstrat():
  function parse_args (line 78) | def parse_args():

FILE: samples/rollover/rollover.py
  class TheStrategy (line 33) | class TheStrategy(bt.Strategy):
    method start (line 34) | def start(self):
    method next (line 39) | def next(self):
  function checkdate (line 56) | def checkdate(dt, d):
  function checkvolume (line 88) | def checkvolume(d0, d1):
  function runstrat (line 92) | def runstrat(args=None):
  function parse_args (line 129) | def parse_args(pargs=None):

FILE: samples/sharpe-timereturn/sharpe-timereturn.py
  function runstrat (line 30) | def runstrat(pargs=None):
  function parse_args (line 99) | def parse_args(pargs=None):

FILE: samples/signals-strategy/signals-strategy.py
  class SMACloseSignal (line 43) | class SMACloseSignal(bt.Indicator):
    method __init__ (line 47) | def __init__(self):
  class SMAExitSignal (line 51) | class SMAExitSignal(bt.Indicator):
    method __init__ (line 55) | def __init__(self):
  function runstrat (line 61) | def runstrat(args=None):
  function parse_args (line 99) | def parse_args(pargs=None):

FILE: samples/sigsmacross/sigsmacross.py
  class SmaCross (line 30) | class SmaCross(bt.SignalStrategy):
    method notify_order (line 33) | def notify_order(self, order):
    method notify_trade (line 42) | def notify_trade(self, trade):
    method __init__ (line 46) | def __init__(self):
  function runstrat (line 53) | def runstrat(pargs=None):
  function parse_args (line 73) | def parse_args(pargs=None):

FILE: samples/sigsmacross/sigsmacross2.py
  class SmaCross (line 25) | class SmaCross(bt.SignalStrategy):
    method __init__ (line 26) | def __init__(self):

FILE: samples/sizertest/sizertest.py
  class CloseSMA (line 31) | class CloseSMA(bt.Strategy):
    method __init__ (line 34) | def __init__(self):
    method next (line 38) | def next(self):
  class LongOnly (line 46) | class LongOnly(bt.Sizer):
    method _getsizing (line 49) | def _getsizing(self, comminfo, cash, data, isbuy):
  class FixedReverser (line 61) | class FixedReverser(bt.Sizer):
    method _getsizing (line 64) | def _getsizing(self, comminfo, cash, data, isbuy):
  function runstrat (line 70) | def runstrat(args=None):
  function parse_args (line 104) | def parse_args(pargs=None):

FILE: samples/slippage/slippage.py
  class SMACrossOver (line 32) | class SMACrossOver(bt.Indicator):
    method __init__ (line 36) | def __init__(self):
  class SlipSt (line 42) | class SlipSt(bt.SignalStrategy):
    method notify_order (line 45) | def notify_order(self, order):
  function runstrat (line 55) | def runstrat(args=None):
  function parse_args (line 104) | def parse_args(pargs=None):

FILE: samples/sratio/sratio.py
  function average (line 18) | def average(x):
  function variance (line 22) | def variance(x):
  function standarddev (line 27) | def standarddev(x):
  function run (line 31) | def run(pargs=None):
  function parse_args (line 50) | def parse_args(pargs=None):

FILE: samples/stop-trading/stop-loss-approaches.py
  class BaseStrategy (line 30) | class BaseStrategy(bt.Strategy):
    method __init__ (line 36) | def __init__(self):
  class ManualStopOrStopTrail (line 44) | class ManualStopOrStopTrail(BaseStrategy):
    method notify_order (line 50) | def notify_order(self, order):
    method next (line 67) | def next(self):
  class ManualStopOrStopTrailCheat (line 73) | class ManualStopOrStopTrailCheat(BaseStrategy):
    method __init__ (line 79) | def __init__(self):
    method notify_order (line 83) | def notify_order(self, order):
    method next (line 94) | def next(self):
  class AutoStopOrStopTrail (line 107) | class AutoStopOrStopTrail(BaseStrategy):
    method notify_order (line 116) | def notify_order(self, order):
    method next (line 132) | def next(self):
  function runstrat (line 165) | def runstrat(args=None):
  function parse_args (line 200) | def parse_args(pargs=None):

FILE: samples/stoptrail/trail.py
  class St (line 30) | class St(bt.Strategy):
    method __init__ (line 41) | def __init__(self):
    method next (line 46) | def next(self):
  function runstrat (line 89) | def runstrat(args=None):
  function parse_args (line 124) | def parse_args(pargs=None):

FILE: samples/strategy-selection/strategy-selection.py
  class St0 (line 29) | class St0(bt.SignalStrategy):
    method __init__ (line 30) | def __init__(self):
  class St1 (line 36) | class St1(bt.SignalStrategy):
    method __init__ (line 37) | def __init__(self):
  class StFetcher (line 43) | class StFetcher(object):
    method __new__ (line 46) | def __new__(cls, *args, **kwargs):
  function runstrat (line 53) | def runstrat(pargs=None):
  function parse_args (line 71) | def parse_args(pargs=None):

FILE: samples/talib/tablibsartest.py
  class TALibStrategy (line 30) | class TALibStrategy(bt.Strategy):
    method __init__ (line 31) | def __init__(self):
  function runstrat (line 36) | def runstrat(args=None):
  function parse_args (line 64) | def parse_args(pargs=None):

FILE: samples/talib/talibtest.py
  class TALibStrategy (line 30) | class TALibStrategy(bt.Strategy):
    method __init__ (line 37) | def __init__(self):
  function runstrat (line 117) | def runstrat(args=None):
  function parse_args (line 146) | def parse_args(pargs=None):

FILE: samples/timers/scheduled-min.py
  class St (line 30) | class St(bt.Strategy):
    method __init__ (line 43) | def __init__(self):
    method prenext (line 71) | def prenext(self):
    method next (line 74) | def next(self):
    method notify_timer (line 84) | def notify_timer(self, timer, when, *args, **kwargs):
    method notify_order (line 93) | def notify_order(self, order):
  function runstrat (line 99) | def runstrat(args=None):
  function parse_args (line 138) | def parse_args(pargs=None):

FILE: samples/timers/scheduled.py
  class St (line 30) | class St(bt.Strategy):
    method __init__ (line 40) | def __init__(self):
    method prenext (line 59) | def prenext(self):
    method next (line 62) | def next(self):
    method notify_timer (line 72) | def notify_timer(self, timer, when, *args, **kwargs):
    method notify_order (line 80) | def notify_order(self, order):
  function runstrat (line 86) | def runstrat(args=None):
  function parse_args (line 126) | def parse_args(pargs=None):

FILE: samples/tradingcalendar/tcal-intra.py
  class NYSE_2016 (line 30) | class NYSE_2016(bt.TradingCalendar):
  class St (line 52) | class St(bt.Strategy):
    method __init__ (line 56) | def __init__(self):
    method prenext (line 59) | def prenext(self):
    method next (line 62) | def next(self):
  function runstrat (line 76) | def runstrat(args=None):
  function parse_args (line 127) | def parse_args(pargs=None):

FILE: samples/tradingcalendar/tcal.py
  class NYSE_2016 (line 30) | class NYSE_2016(bt.TradingCalendar):
  class St (line 46) | class St(bt.Strategy):
    method __init__ (line 50) | def __init__(self):
    method start (line 53) | def start(self):
    method stop (line 56) | def stop(self):
    method prenext (line 60) | def prenext(self):
    method next (line 63) | def next(self):
  function runstrat (line 77) | def runstrat(args=None):
  function parse_args (line 126) | def parse_args(pargs=None):

FILE: samples/vctest/vctest.py
  class TestStrategy (line 33) | class TestStrategy(bt.Strategy):
    method __init__ (line 47) | def __init__(self):
    method notify_data (line 62) | def notify_data(self, data, status, *args, **kwargs):
    method notify_store (line 68) | def notify_store(self, msg, *args, **kwargs):
    method notify_order (line 71) | def notify_order(self, order):
    method notify_trade (line 79) | def notify_trade(self, trade):
    method prenext (line 84) | def prenext(self):
    method next (line 87) | def next(self, frompre=False):
    method start (line 147) | def start(self):
  function runstrategy (line 155) | def runstrategy():
  function parse_args (line 268) | def parse_args():

FILE: samples/volumefilling/volumefilling.py
  class St (line 34) | class St(bt.Strategy):
    method notify_order (line 40) | def notify_order(self, order):
    method __init__ (line 50) | def __init__(self):
    method start (line 53) | def start(self):
    method next (line 68) | def next(self):
  function runstrat (line 100) | def runstrat():
  function parse_args (line 133) | def parse_args():

FILE: samples/vwr/vwr.py
  function runstrat (line 36) | def runstrat(pargs=None):
  function parse_args (line 106) | def parse_args(pargs=None):

FILE: samples/weekdays-filler/weekdaysaligner.py
  class St (line 36) | class St(bt.Strategy):
    method __init__ (line 39) | def __init__(self):
    method next (line 44) | def next(self):
  function runstrat (line 55) | def runstrat():
  function parse_args (line 90) | def parse_args():

FILE: samples/weekdays-filler/weekdaysfiller.py
  class WeekDaysFiller (line 27) | class WeekDaysFiller(object):
    method __init__ (line 33) | def __init__(self, data, fillclose=False):
    method __call__ (line 37) | def __call__(self, data):

FILE: samples/writer-test/writer-test.py
  class LongShortStrategy (line 34) | class LongShortStrategy(bt.Strategy):
    method start (line 48) | def start(self):
    method stop (line 51) | def stop(self):
    method log (line 54) | def log(self, txt, dt=None):
    method __init__ (line 60) | def __init__(self):
    method next (line 70) | def next(self):
    method notify_order (line 91) | def notify_order(self, order):
    method notify_trade (line 110) | def notify_trade(self, trade):
  function runstrategy (line 119) | def runstrategy():
  function parse_args (line 165) | def parse_args():

FILE: samples/yahoo-test/yahoo-test.py
  function runstrat (line 33) | def runstrat():
  function parse_args (line 69) | def parse_args():

FILE: tests/test_analyzer-sqn.py
  class TestStrategy (line 37) | class TestStrategy(bt.Strategy):
    method log (line 46) | def log(self, txt, dt=None, nodate=False):
    method notify_trade (line 54) | def notify_trade(self, trade):
    method notify_order (line 58) | def notify_order(self, order):
    method __init__ (line 84) | def __init__(self):
    method start (line 91) | def start(self):
    method stop (line 108) | def stop(self):
    method next (line 118) | def next(self):
  function test_run (line 154) | def test_run(main=False):

FILE: tests/test_analyzer-timereturn.py
  class TestStrategy (line 37) | class TestStrategy(bt.Strategy):
    method log (line 45) | def log(self, txt, dt=None, nodate=False):
    method notify_order (line 53) | def notify_order(self, order):
    method __init__ (line 79) | def __init__(self):
    method start (line 86) | def start(self):
    method stop (line 102) | def stop(self):
    method next (line 112) | def next(self):
  function test_run (line 147) | def test_run(main=False):

FILE: tests/test_comminfo.py
  function check_stocks (line 30) | def check_stocks():
  function check_futures (line 56) | def check_futures():
  function test_run (line 84) | def test_run(main=False):

FILE: tests/test_data_multiframe.py
  function test_run (line 37) | def test_run(main=False):

FILE: tests/test_data_replay.py
  function test_run (line 40) | def test_run(main=False, exbar=False):

FILE: tests/test_data_resample.py
  function test_run (line 39) | def test_run(main=False):

FILE: tests/test_ind_accdecosc.py
  function test_run (line 37) | def test_run(main=False):

FILE: tests/test_ind_aroonoscillator.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_aroonupdown.py
  function test_run (line 39) | def test_run(main=False):

FILE: tests/test_ind_atr.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_awesomeoscillator.py
  function test_run (line 37) | def test_run(main=False):

FILE: tests/test_ind_bbands.py
  function test_run (line 40) | def test_run(main=False):

FILE: tests/test_ind_cci.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_dema.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_demaenvelope.py
  function test_run (line 40) | def test_run(main=False):

FILE: tests/test_ind_demaosc.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_dm.py
  function test_run (line 41) | def test_run(main=False):

FILE: tests/test_ind_dma.py
  function test_run (line 39) | def test_run(main=False):

FILE: tests/test_ind_downmove.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_dpo.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_dv2.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_ema.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_emaenvelope.py
  function test_run (line 40) | def test_run(main=False):

FILE: tests/test_ind_emaosc.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_envelope.py
  class TS2 (line 40) | class TS2(testcommon.TestStrategy):
    method __init__ (line 41) | def __init__(self):
  function test_run (line 47) | def test_run(main=False):

FILE: tests/test_ind_heikinashi.py
  function test_run (line 40) | def test_run(main=False):

FILE: tests/test_ind_highest.py
  function test_run (line 39) | def test_run(main=False):

FILE: tests/test_ind_hma.py
  function test_run (line 39) | def test_run(main=False):

FILE: tests/test_ind_ichimoku.py
  function test_run (line 42) | def test_run(main=False):

FILE: tests/test_ind_kama.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_kamaenvelope.py
  function test_run (line 40) | def test_run(main=False):

FILE: tests/test_ind_kamaosc.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_kst.py
  function test_run (line 39) | def test_run(main=False):

FILE: tests/test_ind_lowest.py
  function test_run (line 39) | def test_run(main=False):

FILE: tests/test_ind_lrsi.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_macdhisto.py
  function test_run (line 40) | def test_run(main=False):

FILE: tests/test_ind_minperiod.py
  function test_run (line 37) | def test_run(main=False):

FILE: tests/test_ind_momentum.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_momentumoscillator.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_oscillator.py
  class TS2 (line 38) | class TS2(testcommon.TestStrategy):
    method __init__ (line 39) | def __init__(self):
  function test_run (line 45) | def test_run(main=False):

FILE: tests/test_ind_pctchange.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_pctrank.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_pgo.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_ppo.py
  function test_run (line 40) | def test_run(main=False):

FILE: tests/test_ind_pposhort.py
  function test_run (line 40) | def test_run(main=False):

FILE: tests/test_ind_priceosc.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_rmi.py
  function test_run (line 37) | def test_run(main=False):

FILE: tests/test_ind_roc.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_rsi.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_rsi_safe.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_sma.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_smaenvelope.py
  function test_run (line 40) | def test_run(main=False):

FILE: tests/test_ind_smaosc.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_smma.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_smmaenvelope.py
  function test_run (line 40) | def test_run(main=False):

FILE: tests/test_ind_smmaosc.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_stochastic.py
  function test_run (line 39) | def test_run(main=False):

FILE: tests/test_ind_stochasticfull.py
  function test_run (line 40) | def test_run(main=False):

FILE: tests/test_ind_sumn.py
  function test_run (line 39) | def test_run(main=False):

FILE: tests/test_ind_tema.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_temaenvelope.py
  function test_run (line 40) | def test_run(main=False):

FILE: tests/test_ind_temaosc.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_trix.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_tsi.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_ultosc.py
  function test_run (line 37) | def test_run(main=False):

FILE: tests/test_ind_upmove.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_vortex.py
  function test_run (line 39) | def test_run(main=False):

FILE: tests/test_ind_williamsad.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_williamsr.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_wma.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_wmaenvelope.py
  function test_run (line 40) | def test_run(main=False):

FILE: tests/test_ind_wmaosc.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_zlema.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_ind_zlind.py
  function test_run (line 38) | def test_run(main=False):

FILE: tests/test_metaclass.py
  class TestFrompackages (line 23) | class TestFrompackages(testcommon.SampleParamsHolder):
    method __init__ (line 29) | def __init__(self):
  function test_run (line 33) | def test_run(main=False):

FILE: tests/test_order.py
  class FakeCommInfo (line 28) | class FakeCommInfo(object):
    method getvaluesize (line 29) | def getvaluesize(self, size, price):
    method profitandloss (line 32) | def profitandloss(self, size, price, newprice):
    method getoperationcost (line 35) | def getoperationcost(self, size, price):
    method getcommission (line 38) | def getcommission(self, size, price):
  class FakeData (line 42) | class FakeData(object):
    method __len__ (line 47) | def __len__(self):
    method datetime (line 51) | def datetime(self):
    method close (line 55) | def close(self):
  function _execute (line 59) | def _execute(position, order, size, price, partial):
  function test_run (line 87) | def test_run(main=False):

FILE: tests/test_position.py
  function test_run (line 30) | def test_run(main=False):

FILE: tests/test_strategy_optimized.py
  class TestStrategy (line 63) | class TestStrategy(bt.Strategy):
    method log (line 70) | def log(self, txt, dt=None):
    method __init__ (line 75) | def __init__(self):
    method start (line 82) | def start(self):
    method stop (line 87) | def stop(self):
    method next (line 104) | def next(self):
  function test_run (line 121) | def test_run(main=False):

FILE: tests/test_strategy_unoptimized.py
  class TestStrategy (line 56) | class TestStrategy(bt.Strategy):
    method log (line 64) | def log(self, txt, dt=None, nodate=False):
    method notify_order (line 72) | def notify_order(self, order):
    method __init__ (line 98) | def __init__(self):
    method start (line 105) | def start(self):
    method stop (line 121) | def stop(self):
    method next (line 151) | def next(self):
  function test_run (line 186) | def test_run(main=False):

FILE: tests/test_study_fractal.py
  function test_run (line 39) | def test_run(main=False):

FILE: tests/test_trade.py
  class FakeCommInfo (line 30) | class FakeCommInfo(object):
    method getvaluesize (line 31) | def getvaluesize(self, size, price):
    method profitandloss (line 34) | def profitandloss(self, size, price, newprice):
  class FakeData (line 38) | class FakeData(object):
    method __len__ (line 43) | def __len__(self):
    method datetime (line 47) | def datetime(self):
    method close (line 51) | def close(self):
  function test_run (line 55) | def test_run(main=False):

FILE: tests/test_writer.py
  class TestStrategy (line 35) | class TestStrategy(bt.Strategy):
    method __init__ (line 38) | def __init__(self):
  function test_run (line 42) | def test_run(main=False):

FILE: tests/testcommon.py
  function getdata (line 50) | def getdata(index, fromdate=FROMDATE, todate=TODATE):
  function runtest (line 61) | def runtest(datas,
  class TestStrategy (line 120) | class TestStrategy(bt.Strategy):
    method __init__ (line 129) | def __init__(self):
    method prenext (line 151) | def prenext(self):
    method nextstart (line 154) | def nextstart(self):
    method next (line 158) | def next(self):
    method start (line 169) | def start(self):
    method stop (line 172) | def stop(self):
  class SampleParamsHolder (line 226) | class SampleParamsHolder(ParamsBase):
    method __init__ (line 236) | def __init__(self):

FILE: tools/rewrite-data.py
  class RewriteStrategy (line 50) | class RewriteStrategy(bt.Strategy):
    method start (line 56) | def start(self):
    method next (line 70) | def next(self):
  function runstrat (line 96) | def runstrat(pargs=None):
  function parse_args (line 141) | def parse_args(pargs=None):

FILE: tools/yahoodownload.py
  class YahooDownload (line 47) | class YahooDownload(object):
    method __init__ (line 52) | def __init__(self, ticker, fromdate, todate, period='d', reverse=False):
    method writetofile (line 146) | def writetofile(self, filename):
  function parse_args (line 163) | def parse_args():