'ipbddlmZmZmZmZddlZddlZddlZddlZ ejZ ddl Z ddlmZmZmZmZmZmZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lm Z m!Z!m"Z"m#Z#dd l$m%Z%m&Z&dd l'm(Z(m)Z)m*Z*ddl+m,Z,Gdde-Z.Gddeee-Z/y#e $reZ YwxYw))absolute_importdivisionprint_functionunicode_literalsN)maprangezipwith_metaclass string_types integer_types) linebuffer) indicator) BackBroker) MetaParams) observers) WriterFile) OrderedDicttzparsenum2datedate2num)StrategySignalStrategy)TradingCalendarBaseTradingCalendarPandasMarketCalendar)TimerceZdZdZy) OptReturnc j|x|_|_|jD]\}}t|||yN)pparamsitemssetattr)selfr#kwargskvs P/var/www/app/trading-bot/venv/lib/python3.12/site-packages/backtrader/cerebro.py__init__zOptReturn.__init__6s5%%LLN DAq D!Q  N)__name__ __module__ __qualname__r+r,r*rr5s r,rc 6eZdZdZdZdZedZdZd>dZ dZ e je jgd gdd d d d f d Z e je jgd gdd d d d f d Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!d Z"d!Z#d"Z$d?d#Z%d$Z&d%Z'd?d&Z(d?d'Z)d(Z*d)Z+d*Z,d+Z-d,Z.e/e.e-Z0 d@d-Z1d.Z2d/Z3d0Z4d1Z5d2Z6d3Z7dAd4Z8d5Z9d6Z:d7Z;d8Zd;Z?d<Z@dAd=ZAy )BCerebroaO"Params: - ``preload`` (default: ``True``) Whether to preload the different ``data feeds`` passed to cerebro for the Strategies - ``runonce`` (default: ``True``) Run ``Indicators`` in vectorized mode to speed up the entire system. Strategies and Observers will always be run on an event based basis - ``live`` (default: ``False``) If no data has reported itself as *live* (via the data's ``islive`` method but the end user still want to run in ``live`` mode, this parameter can be set to true This will simultaneously deactivate ``preload`` and ``runonce``. It will have no effect on memory saving schemes. Run ``Indicators`` in vectorized mode to speed up the entire system. Strategies and Observers will always be run on an event based basis - ``maxcpus`` (default: None -> all available cores) How many cores to use simultaneously for optimization - ``stdstats`` (default: ``True``) If True default Observers will be added: Broker (Cash and Value), Trades and BuySell - ``oldbuysell`` (default: ``False``) If ``stdstats`` is ``True`` and observers are getting automatically added, this switch controls the main behavior of the ``BuySell`` observer - ``False``: use the modern behavior in which the buy / sell signals are plotted below / above the low / high prices respectively to avoid cluttering the plot - ``True``: use the deprecated behavior in which the buy / sell signals are plotted where the average price of the order executions for the given moment in time is. This will of course be on top of an OHLC bar or on a Line on Cloe bar, difficulting the recognition of the plot. - ``oldtrades`` (default: ``False``) If ``stdstats`` is ``True`` and observers are getting automatically added, this switch controls the main behavior of the ``Trades`` observer - ``False``: use the modern behavior in which trades for all datas are plotted with different markers - ``True``: use the old Trades observer which plots the trades with the same markers, differentiating only if they are positive or negative - ``exactbars`` (default: ``False``) With the default value each and every value stored in a line is kept in memory Possible values: - ``True`` or ``1``: all "lines" objects reduce memory usage to the automatically calculated minimum period. If a Simple Moving Average has a period of 30, the underlying data will have always a running buffer of 30 bars to allow the calculation of the Simple Moving Average - This setting will deactivate ``preload`` and ``runonce`` - Using this setting also deactivates **plotting** - ``-1``: datafreeds and indicators/operations at strategy level will keep all data in memory. For example: a ``RSI`` internally uses the indicator ``UpDay`` to make calculations. This subindicator will not keep all data in memory - This allows to keep ``plotting`` and ``preloading`` active. - ``runonce`` will be deactivated - ``-2``: data feeds and indicators kept as attributes of the strategy will keep all points in memory. For example: a ``RSI`` internally uses the indicator ``UpDay`` to make calculations. This subindicator will not keep all data in memory If in the ``__init__`` something like ``a = self.data.close - self.data.high`` is defined, then ``a`` will not keep all data in memory - This allows to keep ``plotting`` and ``preloading`` active. - ``runonce`` will be deactivated - ``objcache`` (default: ``False``) Experimental option to implement a cache of lines objects and reduce the amount of them. Example from UltimateOscillator:: bp = self.data.close - TrueLow(self.data) tr = TrueRange(self.data) # -> creates another TrueLow(self.data) If this is ``True`` the 2nd ``TrueLow(self.data)`` inside ``TrueRange`` matches the signature of the one in the ``bp`` calculation. It will be reused. Corner cases may happen in which this drives a line object off its minimum period and breaks things and it is therefore disabled. - ``writer`` (default: ``False``) If set to ``True`` a default WriterFile will be created which will print to stdout. It will be added to the strategy (in addition to any other writers added by the user code) - ``tradehistory`` (default: ``False``) If set to ``True``, it will activate update event logging in each trade for all strategies. This can also be accomplished on a per strategy basis with the strategy method ``set_tradehistory`` - ``optdatas`` (default: ``True``) If ``True`` and optimizing (and the system can ``preload`` and use ``runonce``, data preloading will be done only once in the main process to save time and resources. The tests show an approximate ``20%`` speed-up moving from a sample execution in ``83`` seconds to ``66`` - ``optreturn`` (default: ``True``) If ``True`` the optimization results will not be full ``Strategy`` objects (and all *datas*, *indicators*, *observers* ...) but and object with the following attributes (same as in ``Strategy``): - ``params`` (or ``p``) the strategy had for the execution - ``analyzers`` the strategy has executed In most occassions, only the *analyzers* and with which *params* are the things needed to evaluate a the performance of a strategy. If detailed analysis of the generated values for (for example) *indicators* is needed, turn this off The tests show a ``13% - 15%`` improvement in execution time. Combined with ``optdatas`` the total gain increases to a total speed-up of ``32%`` in an optimization run. - ``oldsync`` (default: ``False``) Starting with release 1.9.0.99 the synchronization of multiple datas (same or different timeframes) has been changed to allow datas of different lengths. If the old behavior with data0 as the master of the system is wished, set this parameter to true - ``tz`` (default: ``None``) Adds a global timezone for strategies. The argument ``tz`` can be - ``None``: in this case the datetime displayed by strategies will be in UTC, which has been always the standard behavior - ``pytz`` instance. It will be used as such to convert UTC times to the chosen timezone - ``string``. Instantiating a ``pytz`` instance will be attempted. - ``integer``. Use, for the strategy, the same timezone as the corresponding ``data`` in the ``self.datas`` iterable (``0`` would use the timezone from ``data0``) - ``cheat_on_open`` (default: ``False``) The ``next_open`` method of strategies will be called. This happens before ``next`` and before the broker has had a chance to evaluate orders. The indicators have not yet been recalculated. This allows issuing an orde which takes into account the indicators of the previous day but uses the ``open`` price for stake calculations For cheat_on_open order execution, it is also necessary to make the call ``cerebro.broker.set_coo(True)`` or instantite a broker with ``BackBroker(coo=True)`` (where *coo* stands for cheat-on-open) or set the ``broker_coo`` parameter to ``True``. Cerebro will do it automatically unless disabled below. - ``broker_coo`` (default: ``True``) This will automatically invoke the ``set_coo`` method of the broker with ``True`` to activate ``cheat_on_open`` execution. Will only do it if ``cheat_on_open`` is also ``True`` - ``quicknotify`` (default: ``False``) Broker notifications are delivered right before the delivery of the *next* prices. For backtesting this has no implications, but with live brokers a notification can take place long before the bar is delivered. When set to ``True`` notifications will be delivered as soon as possible (see ``qcheck`` in live feeds) Set to ``False`` for compatibility. May be changed to ``True`` ))preloadT)runonceT)maxcpusN)stdstatsT) oldbuysellF) oldtradesF) lookaheadr) exactbarsF)optdatasT) optreturnT)objcacheF)liveF)writerF) tradehistoryF)oldsyncF)tzN) cheat_on_openF) broker_cooT) quicknotifyFcd|_d|_d|_t|_t|_t|_tj|_ t|_ t|_ t|_ t|_ t|_t|_t|_t|_t|_t|_d|_d|_d|_t1j2d|_t7|_||j8_d|_t|_t|_ d|_!y)NFNNNr)"_dolive _doreplay _dooptimizeliststoresfeedsdatas collectionsr datasbynamestratsoptcbsr analyzers indicatorsdictsizerswritersstorecbsdatacbssignals _signal_strat_signal_concurrent_signal_accumulate itertoolscount_dataidr_brokercerebro _tradingcal _pretimers _ohistory _fhistoryr&s r*r+zCerebro.__init__(s  f V V &224f f &f v  v v /"'"' q) !| # &r,ct}|D]D}t|tr|f}nt|tjs|f}|j |F|S)zlHandy function which turns things into things that can be iterated upon including iterables )rK isinstancer collectionsAbcIterableappend)iterable niterableelems r*iterizezCerebro.iterizeIsX F  #D$ -wn&=&=>w   T "  #r,c||_y)a4 Add a history of orders to be directly executed in the broker for performance evaluation - ``fund``: is an iterable (ex: list, tuple, iterator, generator) in which each element will be also an iterable (with length) with the following sub-elements (2 formats are possible) ``[datetime, share_value, net asset value]`` **Note**: it must be sorted (or produce sorted elements) by datetime ascending where: - ``datetime`` is a python ``date/datetime`` instance or a string with format YYYY-MM-DD[THH:MM:SS[.us]] where the elements in brackets are optional - ``share_value`` is an float/integer - ``net_asset_value`` is a float/integer N)rf)r&funds r*set_fund_historyzCerebro.set_fund_historyYs ,r,Tc>|jj||fy)a Add a history of orders to be directly executed in the broker for performance evaluation - ``orders``: is an iterable (ex: list, tuple, iterator, generator) in which each element will be also an iterable (with length) with the following sub-elements (2 formats are possible) ``[datetime, size, price]`` or ``[datetime, size, price, data]`` **Note**: it must be sorted (or produce sorted elements) by datetime ascending where: - ``datetime`` is a python ``date/datetime`` instance or a string with format YYYY-MM-DD[THH:MM:SS[.us]] where the elements in brackets are optional - ``size`` is an integer (positive to *buy*, negative to *sell*) - ``price`` is a float/integer - ``data`` if present can take any of the following values - *None* - The 1st data feed will be used as target - *integer* - The data with that index (insertion order in **Cerebro**) will be used - *string* - a data with that name, assigned for example with ``cerebro.addata(data, name=value)``, will be the target - ``notify`` (default: *True*) If ``True`` the 1st strategy inserted in the system will be notified of the artificial orders created following the information from each order in ``orders`` **Note**: Implicit in the description is the need to add a data feed which is the target of the orders. This is for example needed by analyzers which track for example the returns N)rerl)r&ordersnotifys r*add_order_historyzCerebro.add_order_historyqsN vv./r,cy)aReceives a timer notification where ``timer`` is the timer which was returned by ``add_timer``, and ``when`` is the calling time. ``args`` and ``kwargs`` are any additional arguments passed to ``add_timer`` The actual ``when`` time can be later, but the system may have not be able to call the timer before. This value is the timer value and no the system time. Nr0)r&timerwhenargsr's r* notify_timerzCerebro.notify_timers r,FNc t| t|j|| |||||||| | | d |}|jj||S)zInternal method to really create the timer (not started yet) which can be called by cerebro instances or other objects which can access cerebro) tidownerrQrzoffsetrepeatweekdays weekcarry monthdays monthcarryallowtzdatacheat)rlenrdrl)r&rrzrrrrrrrrrQrr{r'rys r* _add_timerzCerebro._add_timersbDOO$fVJ     u% r,c @|j| |||||||||| | | d | S)a Schedules a timer to invoke ``notify_timer`` Arguments: - ``when``: can be - ``datetime.time`` instance (see below ``tzdata``) - ``bt.timer.SESSION_START`` to reference a session start - ``bt.timer.SESSION_END`` to reference a session end - ``offset`` which must be a ``datetime.timedelta`` instance Used to offset the value ``when``. It has a meaningful use in combination with ``SESSION_START`` and ``SESSION_END``, to indicated things like a timer being called ``15 minutes`` after the session start. - ``repeat`` which must be a ``datetime.timedelta`` instance Indicates if after a 1st call, further calls will be scheduled within the same session at the scheduled ``repeat`` delta Once the timer goes over the end of the session it is reset to the original value for ``when`` - ``weekdays``: a **sorted** iterable with integers indicating on which days (iso codes, Monday is 1, Sunday is 7) the timers can be actually invoked If not specified, the timer will be active on all days - ``weekcarry`` (default: ``False``). If ``True`` and the weekday was not seen (ex: trading holiday), the timer will be executed on the next day (even if in a new week) - ``monthdays``: a **sorted** iterable with integers indicating on which days of the month a timer has to be executed. For example always on day *15* of the month If not specified, the timer will be active on all days - ``monthcarry`` (default: ``True``). If the day was not seen (weekend, trading holiday), the timer will be executed on the next available day. - ``allow`` (default: ``None``). A callback which receives a `datetime.date`` instance and returns ``True`` if the date is allowed for timers or else returns ``False`` - ``tzdata`` which can be either ``None`` (default), a ``pytz`` instance or a ``data feed`` instance. ``None``: ``when`` is interpreted at face value (which translates to handling it as if it where UTC even if it's not) ``pytz`` instance: ``when`` will be interpreted as being specified in the local time specified by the timezone instance. ``data feed`` instance: ``when`` will be interpreted as being specified in the local time specified by the ``tz`` parameter of the data feed instance. **Note**: If ``when`` is either ``SESSION_START`` or ``SESSION_END`` and ``tzdata`` is ``None``, the 1st *data feed* in the system (aka ``self.data0``) will be used as the reference to find out the session times. - ``strats`` (default: ``False``) call also the ``notify_timer`` of strategies - ``cheat`` (default ``False``) if ``True`` the timer will be called before the broker has a chance to evaluate the orders. This opens the chance to issue orders based on opening price for example right before the session starts - ``*args``: any extra args will be passed to ``notify_timer`` - ``**kwargs``: any extra kwargs will be passed to ``notify_timer`` Return Value: - The created timer ) rrzrrrrrrrrrQr)r)r&rzrrrrrrrrrQrr{r's r* add_timerzCerebro.add_timersFvt  T&J&    r,c&||j_y)a This can also be done with the parameter ``tz`` Adds a global timezone for strategies. The argument ``tz`` can be - ``None``: in this case the datetime displayed by strategies will be in UTC, which has been always the standard behavior - ``pytz`` instance. It will be used as such to convert UTC times to the chosen timezone - ``string``. Instantiating a ``pytz`` instance will be attempted. - ``integer``. Use, for the strategy, the same timezone as the corresponding ``data`` in the ``self.datas`` iterable (``0`` would use the timezone from ``data0``) N)r"rB)r&rBs r*addtzz Cerebro.addtz!s& r,ct|trt|}||_yt|drt|}||_y t |t r|}||_y#t $r Y||_ywxYw)aAdds a global trading calendar to the system. Individual data feeds may have separate calendars which override the global one ``cal`` can be an instance of ``TradingCalendar`` a string or an instance of ``pandas_market_calendars``. A string will be will be instantiated as a ``PandasMarketCalendar`` (which needs the module ``pandas_market_calendar`` installed in the system. If a subclass of `TradingCalendarBase` is passed (not an instance) it will be instantiated )calendar valid_daysN)rir rhasattr issubclassr TypeErrorrc)r&cals r* addcalendarzCerebro.addcalendar6s c< (&4CS, '&4C  c#67%C  sA%% A87A8cB|jj||||fy)zUAdds a signal to the system which will be later added to a ``SignalStrategy``N)rZrl)r&sigtypesigclssigargs sigkwargss r* add_signalzCerebro.add_signalPs WfgyABr,c|||f|_y)z7Adds a SignalStrategy subclass which can accept signalsN)r[)r&stratclsr{r's r*signal_strategyzCerebro.signal_strategyUs&f5r,c||_y)zyIf signals are added to the system and the ``concurrent`` value is set to True, concurrent orders will be allowedN)r\r&onoffs r*signal_concurrentzCerebro.signal_concurrentYs #(r,c||_y)zIf signals are added to the system and the ``accumulate`` value is set to True, entering the market when already in the market, will be allowed to increase a positionN)r]rs r*signal_accumulatezCerebro.signal_accumulate^s #(r,cX||jvr|jj|yy)z8Adds an ``Store`` instance to the if not already presentN)rLrl)r&stores r*addstorezCerebro.addstoreds%  # KK  u % $r,c@|jj|||fy)zkAdds an ``Writer`` class to the mix. Instantiation will be done at ``run`` time in cerebro N)rWrl)r&wrtclsr{r's r* addwriterzCerebro.addwriteris VT623r,c(|||f|jd<y)zoAdds a ``Sizer`` class (and args) which is the default sizer for any strategy added to cerebro NrV)r&sizerclsr{r's r*addsizerzCerebro.addsizeros&tV4 Dr,c(|||f|j|<y)zAdds a ``Sizer`` class by idx. This idx is a reference compatible to the one returned by ``addstrategy``. Only the strategy referenced by ``idx`` will receive this size Nr)r&idxrr{r's r*addsizer_byidxzCerebro.addsizer_byidxus %dF3 Cr,c@|jj|||fy)z Adds an ``Indicator`` class to the mix. Instantiation will be done at ``run`` time in the passed strategies N)rTrl)r&indclsr{r's r* addindicatorzCerebro.addindicator|s f56r,c@|jj|||fy)zk Adds an ``Analyzer`` class to the mix. Instantiation will be done at ``run`` time N)rSrl)r&anclsr{r's r* addanalyzerzCerebro.addanalyzers udF34r,cB|jjd|||fy)zk Adds an ``Observer`` class to the mix. Instantiation will be done at ``run`` time FNrrlr&obsclsr{r's r* addobserverzCerebro.addobservers ufdF; Adds an ``Observer`` class to the mix. Instantiation will be done at ``run`` time It will be added once per "data" in the system. A use case is a buy/sell observer which observes individual datas. A counter-example is the CashValue, which observes system-wide values TNrrs r*addobservermultizCerebro.addobservermultis tVT6:;r,c:|jj|y)aAdds a callback to get messages which would be handled by the notify_store method The signature of the callback must support the following: - callback(msg, \*args, \*\*kwargs) The actual ``msg``, ``*args`` and ``**kwargs`` received are implementation defined (depend entirely on the *data/broker/store*) but in general one should expect them to be *printable* to allow for reception and experimentation. N)rXrlr&callbacks r* addstorecbzCerebro.addstorecbs X&r,cj|jD]}||g|i||j|g|i|yr!)rX notify_store)r&msgr{r'rs r* _notify_storezCerebro._notify_storesC  +H S *4 *6 * + #///r,cy)auReceive store notifications in cerebro This method can be overridden in ``Cerebro`` subclasses The actual ``msg``, ``*args`` and ``**kwargs`` received are implementation defined (depend entirely on the *data/broker/store*) but in general one should expect them to be *printable* to allow for reception and experimentation. Nr0)r&rr{r's r*rzCerebro.notify_store r,c|jD]Z}|jD]E}|\}}}|j|g|i||jD]}|j|g|i|G\yr!)rLget_notificationsr runningstratsr)r&rnotifrr{r'strats r* _storenotifyzCerebro._storenotifys[[ =E002 =$)!T6"""3888!//=E&E&&su >v > QU #r,c tfd|jDrjjdi||j |d|_S)aX Adds a ``Data Feed`` to be replayed by the system If ``name`` is not None it will be put into ``data._name`` which is meant for decoration/plotting purposes. Any other kwargs like ``timeframe``, ``compression``, ``todate`` which are supported by the replay filter will be passed transparently c3&K|]}|u ywr!r0.0xrs r* z%Cerebro.replaydata..61x1}1rTr0)anyrNclonereplayrrIr&rrr's ` r* replaydatazCerebro.replaydata,sP 1djj1 1~~'H!&! XD )r,c tfd|jDrjjdi||j |d|_S)aZ Adds a ``Data Feed`` to be resample by the system If ``name`` is not None it will be put into ``data._name`` which is meant for decoration/plotting purposes. Any other kwargs like ``timeframe``, ``compression``, ``todate`` which are supported by the resample filter will be passed transparently c3&K|]}|u ywr!r0rs r*rz'Cerebro.resampledata..IrrrTr0)rrNrresamplerrIrs ` r* resampledatazCerebro.resampledata?sR 1djj1 1~~'H#F# XD )r,c:|jj|y)z Adds a *callback* to the list of callbacks that will be called with the optimizations when each of the strategies has been run The signature: cb(strategy) N)rRrl)r&cbs r* optcallbackzCerebro.optcallbackRs 2r,cd|_|j|}tj|}t |}|j|j }tj|}t ttj||}t t|} tj|g|| } |jj| y)aQ Adds a ``Strategy`` class to the mix for optimization. Instantiation will happen during ``run`` time. args and kwargs MUST BE iterables which hold the values to check. Example: if a Strategy accepts a parameter ``period``, for optimization purposes the call to ``optstrategy`` looks like: - cerebro.optstrategy(MyStrategy, period=(15, 25)) This will execute an optimization for values 15 and 25. Whereas - cerebro.optstrategy(MyStrategy, period=range(15, 25)) will execute MyStrategy with ``period`` values 15 -> 25 (25 not included, because ranges are semi-open in Python) If a parameter is passed but shall not be optimized the call looks like: - cerebro.optstrategy(MyStrategy, period=(15,)) Notice that ``period`` is still passed as an iterable ... of just 1 element ``backtrader`` will anyhow try to identify situations like: - cerebro.optstrategy(MyStrategy, period=15) and will create an internal pseudo-iterable if possible TN) rJrpr^productrKvaluesrr rrUrQrl) r&strategyr{r'optargsoptkeysvalsoptvalsokwargs1 optkwargsits r* optstrategyzCerebro.optstrategy[sB ||D!##T*v,||FMMO,##T*sI,,W5w?h'   z7I > 2r,cp|jj|||fgt|jdz S)aN Adds a ``Strategy`` class to the mix for a single pass run. Instantiation will happen during ``run`` time. args and kwargs will be passed to the strategy as they are during instantiation. Returns the index with which addition of other objects (like sizers) can be referenced r)rQrlr)r&r r{r's r* addstrategyzCerebro.addstrategys4 XtV4564;;!##r,c"||_||_|S)zz Sets a specific ``broker`` instance for this strategy, replacing the one inherited from cerebro. )rarb)r&brokers r* setbrokerzCerebro.setbrokers   r,c|jS)zw Returns the broker instance. This is also available as a ``property`` by the name ``broker`` )rargs r* getbrokerzCerebro.getbrokers ||r,c p|jdkDry|sAddlm} |jjr| j di| }n| j di| }g} |jD]Q}t|D]1\}}|j||dz||||| }| j|3|jS| S)aY Plots the strategies inside cerebro If ``plotter`` is None a default ``Plot`` instance is created and ``kwargs`` are passed to it during instantiation. ``numfigs`` split the plot in the indicated number of charts reducing chart density if wished ``iplot``: if ``True`` and running in a ``notebook`` the charts will be displayed inline ``use``: set it to the name of the desired matplotlib backend. It will take precedence over ``iplot`` ``start``: An index to the datetime line array of the strategy or a ``datetime.date``, ``datetime.datetime`` instance indicating the start of the plot ``end``: An index to the datetime line array of the strategy or a ``datetime.date``, ``datetime.datetime`` instance indicating the end of the plot ``width``: in inches of the saved figure ``height``: in inches of the saved figure ``dpi``: quality in dots per inches of the saved figure ``tight``: only save actual content and not the frame of the figure rNr)plotd)figidnumfigsiplotstartenduser0) _exactbarsrr"rA Plot_OldSyncPlot runstrats enumeraterlshow)r&plotterrrrr widthheightdpitightr!r'rfigs stratlistsirrfigs r*rz Cerebro.plotsD ??Q   vv~~+$++5f5#$))-f- I&y1 " E||Ec,35*/Sc$C  D!  " LLN  r,c|jjxr|jxr |j}|j ||S)zw Used during optimization to pass the cerebro over the multiprocesing module without complains )predata)r"r; _dopreload _dorunonce runstrategies)r& iterstratr3s r*__call__zCerebro.__call__s9 &&//IdooI$//!!)W!==r,cFt|j}d|vr|d=|S)z Used during optimization to prevent optimization result `runstrats` from being pickled to subprocesses r&)varscopy)r&rvs r* __getstate__zCerebro.__getstate__s( $Z__  " ; r,cd|_y)zIf invoked from inside a strategy or anywhere else, including other threads the execution will stop as soon as possible.TN) _event_stoprgs r*runstopzCerebro.runstops  r,c d|_|jsgS|jj}|j D]!\}}||vs t |j||#t jjtjjt jj|jjtjj|jj|jj|_|jj |_t%|jj&|_|j(r)d|_|j"xr|j(dk|_|j*xst-d|jD|_|j*rd|_|j.s|jj0rd|_d|_t3|_|jj6dur%t9}|j4j;||j<D])\}}}||i|}|j4j;|+t-t?d|j4|_ t3|_!|jDr|jF\} } } | R |jHjKd\} } } tM| tNs"|jHjQd| | | fd} | tNtUtW} } } |jX| g| |jZ|j\|jDd| |jHs|jYt^tajb|jH} |jdr|jjfdk(r[| D]T} |ji| }|jBj;||jds<|jjD] }|| Vn|jjlr|j"r|jr|jD]t}|jo|j(dkr&|jq|jjr |ju|j"se|j!vtwjx|jjfxsd}|j{|| D]6}|jBj;||jjD] }|| 8|j}|jjlr9|j"r-|jr!|jD]}|j|jds|jBdS|jBS#tR$rYwxYw) a)The core method to perform backtesting. Any ``kwargs`` passed to it will affect the value of the standard parameters ``Cerebro`` was instantiated with. If ``cerebro`` has not datas the method will immediately bail out. It has different return values: - For No Optimization: a list contanining instances of the Strategy classes added with ``addstrategy`` - For Optimization: a list of lists which contain instances of the Strategy classes added with ``addstrategy`` Frc34K|]}|jywr! replaying)rrs r*rzCerebro.run...s.Oqq{{.OTc.|jjSr!)r"csvrs r*zCerebro.run..FsQSSWWr,Nr) _accumulate _concurrentrZsize)@r?rNr#_getkeysr$r%r LineActions cleancacher Indicatorusecacher"r=r4r5r3r4intr:r"rIrrHr>rK runwritersr?rrlrWr writers_csvr&rZr[rQrririnsert IndexErrortuplerUrr]r\rr^rrJr5r6rRr;resetextendr9_startmultiprocessingPoolimapclosestop)r&r'pkeyskeyvalwrwrclswrargswrkwargssignalstsargsskwargs iterstratsr7runstratrrpoolrs r*runz Cerebro.runs!zzI $$&  /HCe| S#. / ))+&&(''8$$TVV__5&&..&&..dff../ ??#DO"ooE$//A2EDOO3.ODJJ.O+O >>$DO <<466;;#DO#DO& 66==D B OO " "2 &(,|| ' #E68+(+B OO " "2 & ' s#4dooFG <<'+'9'9 $HeW(/3{{q/A,HeW&h? **1x.HI#'+957DF% D  X ($  ()-)@)@)-)@)@%)\\ ( '  ({{   X &&& 4 466>>Q#6( % --i8%%h/##"kk%8 %  %vv4??t JJ'DJJL* )>)> ?KKM  '#''(>$?DYYtZ0 %%a(++BqE  JJLvv4??t JJ DIIK >>!$ $~~w"sW// W<;W<c8tjd|_y)Nr)r^r_stcountrgs r* _init_stcountzCerebro._init_stcounts q) r,c,t|jSr!)rrqrgs r* _next_stidzCerebro._next_stidsDLL!!r,c|jtx|_}|jD]}|j |j j rG|j jr1t|jdr|jjd|j%|jj|j|jD]!\}}|jj||#|jj |jD]}|j |j rt}|j"D].} | j$s|j'| j)0|j*D]*} | j j$s| j-|,|s|j"D]t} | j/|j0dkr&| j'|j2j4| j7|j8se| j;v|D]{\} } } |j"t| z} | | i| }|j jBrd|_"|j jFr|jI|jK|}|j jL}tO|tPr|j"|jR}n tU|}|r|jVjYdd}t[|D]'\}}|j j\r|j_dt`jb|j jdr!|j_dt`jfn"|j_dt`jfd|j jhstk|j"dk(r!|j_dt`jln |j_dt`jn|j`D]\}}}}|j^||g|i| |jpD]\}}}|jr|g|i||jtD]\}}}|jv|g|i||jVjY||\}} } ||jx|g| i| |j{||j7|j*D]8} | j j$s| j-|j):*|s.|D])}|j}|j0|j~ +|j*D]} | j g|_@g|_A|jD]m}|j |j"d |j2jr|jjK|S|jjK|o|j8rF|jr:|j jBr|j|nK|j|n9|j jBr|j|n|j||D]}|j|jj|s!|j"D]} | j|jD]}|j|jD]}|j|j||jr|j jrt}|D]}|jtD]?}d|_Nd|_Ot|D]!} | jd st|| d#At|j2|jtt| }!|jK|!|S|S#t<j>j@$rY wxYw) zP Internal method invoked by ``run``` to run a set of strategies set_cooTNrrLrGF)barplotrCrr)rS strategycls)UrrrKrrLrr"rCrDrrarvrfrsrerwrMrUrNrGrZgetwriterheadersrT addheadersrYr"r#r9r[r4r3rerrorsStrategySkipErrorrA_oldsyncr@set_tradehistoryrlrBrir _tzrrVgetr'r6 _addobserverrBrokerr7BuySellr8rTrades DataTradesrT _addindicatorrS _addanalyzer _addsizer_settzqbufferrI_timers _timerscheatrdrr5 _runonce_old_runonce _runnext_old_runnext_stopr` stop_writersrJr<r _parentdir startswithr%rtype)"r&r7r3r&rruonotifyrwheadersrr?rrirjrrB defaultsizerrmultirobsargs obskwargsrindargs indkwargsranargsankwargssizerryresultsaattrnameoreturns" r*r6zCerebro.runstrategiess )-/Y[[ E KKM  66  DFF$5$5t||Y/ $$T* >> % LL ) )$.. 9#~~ .>?vv((**41B1BC**41B1B37+9vv''3tzz?a+?**5)2B2BC**5)2F2FG9=M5E67I&E&&ufLwL)LM37//G.FGY'E''FFIFG04~~C+E68&E&&uBvBBC)- \(J%ug$#EOOE=E=W= R  "ooDFxx||))%*@*@*BCD= DD&MEMM$//T^^MLM//   DL "D  / DJJqM*<<%%%%,,U3LL''. /4??66>>%%i0MM),66>>%%i0MM),"        JJ D IIK [[ E JJL  )$    0 0fG" (7A!%AJ $AI$'F7#..v6#Ax677$ELLEOOY]^cYdew' (Ng99..  s/`;;aact}t}t|jD]\}}|j|d|z<||d<t }|D]+}|j j }|j||<-||d<|jD]-} | jt || j/y)NzData%dDatas Strategies)r2) rr'rN getwriterinforU __class__r-rT writedictr`) r&r& cerebroinfo datainfosir stratinfosrstnamer?s r*rzCerebro.stop_writers<s!m M  , ;GAt&*&8&8&:Ihl # ; ) GV  7E__--F!&!4!4!6Jv  7%/ L!oo F   T+6 7 KKM r,c|jj |jj}|y|j}||jd}|j ||j jb)zu Internal method which kicks the broker and delivers any broker notification to the strategy Nr)rE)rarget_notificationrr_addnotificationr"rE)r&orderrs r* _brokernotifyzCerebro._brokernotifyPsq LL113E}KKE}**1-  " "5dff6H6H " Ir,c|jd}d}|s|d}|j|jry|j|jry|j }|rL|jddD]9}|j |r|j ||j |;ns|5|j |jddD]}|j n<|j }|jddD]}||j |z }|sn||j|jry|j|jry|s|r6|D]1}|j|jry|j|3|r||j|jry|j|jryy) Actual implementation of run in full next mode. All objects have its ``next`` method invoke on each data arrival rTNFr datamaster forcedata) rNrr?rr_check_lastr_next _next_writers)r&r&data0d0retlastretrrs r*rzCerebro._runnext_oldas  1 u}G        JJLE JJqrN4D9996 e 4 U 34   JJqrN"DKKM" ++- JJqrN.allANN%Cr,rbrNrTc34K|]}|jywr!)_clonerrs r*rz#Cerebro._runnext..s1a1rEFc3<K|]}|jywr!) haslivedatars r*rz#Cerebro._runnext..s?A ?sc3NK|]}|j|jk(ywr!) _laststatusLIVErs r*rz#Cerebro._runnext..sGA  7Gs#%)ticksc3 K|]}|ywr!r0rdrets r*rz#Cerebro._runnext.. s0$0s c3$K|]}|du ywr!r0rs r*rz#Cerebro._runnext..s!A4$$,!Asc3&K|] }|| ywr!r0rs r*rz#Cerebro._runnext..s?Qq?sc34K|]\}}||vr|ywr!r0)rrrrsonlys r*rz#Cerebro._runnext..s)ETQ"#-AVO !Esr)rr)forcerr)#sortedrNr' resamplingrDrsumrrmaxrrr?rutcnow do_qcheck total_secondsrlrminindexr _dtmaster _udtmasterrrewind _tick_fillr _check_timersr"rC _next_openrrr)!r&r&rNdatas1rrrrrsrp onlyresample noresample clonecountldatasldatas_noclones lastqcheckdt0 newqcheck livecountrdretsqstartrqlapsedtsretdmasterdtidirpirrrs! @r*rzCerebro._runnexts tzzCEqra%e, =DAq a = =%e,  QVV%V01 2 0%01ES!A5!AB'.FFAsJJsuQx003EF :?#?@CEYs^EFC  #/!(!1!1#!6"*3-(. FAs aAHHwH/vvv>!"AA (n 6FAs"1X#9#& " !#MMM5 6""DKKM" ++-"66''!*#((*++"#    ""9c"?&2EKKM''&&y1 2cu}r           S> <7sS2 S2S83S8$S>c|D]"}|j|j$t|jd} |Dcgc]}|j }}t |}|t dk(ryt|d}t|D]\}} | |kr||j |j||d|jjr%|D] }|j|js y|j|jry|j||d|D]2}|j!||jry|j#|4*cc}w) z Actual implementation of run in vector mode. Strategies are still invoked on a pseudo-event mode in which ``next`` is called for each data arrival c2|j|jfSr!rrHs r*rIz"Cerebro._runonce..rr,rTinfrrNF)rrYrrN advance_peekrfloatrr'rrr"rC_oncepost_openr?rrr) r&r&rrNrrrslenrr s r*rzCerebro._runonceqsm E KKM KKM tzzCE-231>>#3C3c(CeEl"y|$D#C. 3#:!H$$&     y#T  :vv##&E((*''       y#U  ;" .$##""9-  .A3sE+c|s |jn |j}|D]}|j|s|jjj ||j g|ji|j|jjsu|D]7}|j ||j g|ji|j9yr!) rrcheckr#rr|lastwhenr{r'rQ)r&r&rrtimerstrs r*rzCerebro._check_timerss%*0A0A KA773< 'AHHNN ' '1:: K K!(( Kxx&KE&E&&q!**JqvvJJK Kr,)Tr!) NrTNN i,TN)F)Br-r.r/__doc__r#r+ staticmethodrprsrwr|r timedeltarrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrpropertyrrr8r=r@rorrrtr6rrrrrrrrrr0r,r*r2r2<sSjF,B  0'0R  -(,,.7Ix7I7I7K%DuE 4,++-6Hh6H6H6J4e5 aF*4C 6( ( & 4 5 475= < '0  = &E8  0"&&&/b $i +FHL:>>@>  EN*"gR(J"@D.@"& Un7.r Kr,r2)0 __future__rrrrrrOr^r\abcrjAttributeError backtraderr utils.py3rr r r r r r#rrbrokersrmetabaserrr?rutilsrrrrr rr tradingcalrrrryrobjectrr2r0r,r*r)s***! __N'' ;;.//   xKnZ0xK;! N!s B$$B.-B.