'itddlmZmZmZmZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z mZmZmZmZmZmZmZddlZddlmZmZddlmZddlmZddlmZm Z dd l!m"Z"dd l#m$Z$m%Z%m&Z&Gd d ejNZ(Gd dee(eZ)Gdde)jNZ*Gddee*e)Z+y))absolute_importdivisionprint_functionunicode_literalsN) filterkeys integer_types iteritems itervaluesmapMAXINT string_typeswith_metaclass) LineIterator StrategyBase) LineSingle)LineSeriesStub)ItemCollection findowner)Trade) OrderedDictAutoOrderedDict AutoDictListcTeZdZeZfdZfdZfdZfdZfdZ xZ S) MetaStrategycd|vr|jd|d<d|vr|jd|d<tt|||||S)Nnotify notify_ordernotify_operation notify_trade)popsuperr__new__)metanamebasesdct __class__s Q/var/www/app/trading-bot/venv/lib/python3.12/site-packages/backtrader/strategy.pyr$zMetaStrategy.__new__.sQ s?"%''("3C   $"%''*<"=C \40tUCHHctt| ||||js(|dk7r"|j ds||j |<yyyy)zH Class has already been created ... register subclasses Strategy_N)r#r__init__aliased startswith_indcol)clsr&r'r(r)s r*r/zMetaStrategy.__init__9sM lC)$s;{{ : dooc&: #CKK '; r+ctt| |i|\}}}t|tj x|_x|_}|j|_ |||fSN) r#rdonewrbtCerebroenvcerebro _next_stid_id)r3argskwargs_objr:r)s r*r6zMetaStrategy.donewDs]"<;TLVLdF-6dBJJ,GGG4<'%%'T6!!r+c:tt| |g|i|\}}}|jj|_t j j|_t|_ t|_ tjt|_t|_t#x|_|_t#|_tjt*j,|_t|_t|_d|_|||fS)NF)r#r dopreinitr9brokerr7sizers FixedSize_sizerlist_orders_orderspending collections defaultdictr_trades_tradespendingrstats observers analyzers itertoolscount_alnameswriters_slave_analyzers_tradehistoryonr3r?r=r>r)s r*rAzMetaStrategy.dopreinitMs , .t Ed Ef E dFhhoo ii))+ v "f"..|< "f&4&66 T^')#// @ v $$T6!!r+ctt| |g|i|\}}}|jj ||j |||fSr5)r#r dopostinitrEsetrBrVs r*rXzMetaStrategy.dopostinitbsL , / Ft Fv F dF dkk*T6!!r+) __name__ __module__ __qualname__dictr2r$r/r6rArX __classcell__r)s@r*rr+s)fG I $""*""r+rceZdZdZej ZdZdZdZ dAdZ dZ dZ d Z d Zd Zd Zd ZdZdZdZdZdZdZfdZdZfdZdBdZdBdZdZdZdZdZ dZ!dZ"dZ#d Z$dCd!Z%d"Z&dBd#Z'ggfd$Z(e)jTe)jTgdgdd%d%df d&Z+d'Z,d(Z-d)Z.d*Z/d+Z0d,Z1d-Z2d.Z3d/Z4d0Z5 dDd1Z6 dDd2Z7dEd3Z8d%d%d%d%e9jtjvd%dd%d%id%e9jtjxid%e9jtjvifd4Z=d%d%d%d%e9jtjvd%dd%d%id%e9jtjxid%e9jtjvifd5Z>dFd6Z?dGd7Z@dHd8ZAdEd9ZBeCeBZDdEd:ZEeCeEZFdId;ZGeCeGZHdId<ZIeCeIZJd=ZKd>ZLd?ZMeCeMeLZNdJd@ZOxZPS)Kr-zB Base class to be subclassed for user defined strategies. TF)datetimerc|dkr`|j|jD]C}t|tf}|s|dkr|jj }|j |Ey|dkDr~|jD]}|j ||jD]}|j d|jD](}|j|D]}|j d*yy)aSEnable the memory saving schemes. Possible values for ``savemem``: 0: No savings. Each lines object keeps in memory all values 1: All lines objects save memory, using the strictly minimum needed Negative values are meant to be used when plotting is required: -1: Indicators at Strategy Level and Observers do not enable memory savings (but anything declared below it does) -2: Same as -1 plus activation of memory saving for any indicators which has declared *plotinfo.plot* as False (will not be plotted) r)savemem) replayingrN) _lineiteratorsIndType isinstancerplotinfoplotqbufferdataslines) selfrdreindsubsavedatalineitclsits r*rkzStrategy.qbufferxs Q;**4<<8 -$S:-87R<"%,,"3"33G G ,  - q[  2 y 1 2  ( Q ' (,, *--e4*BJJqJ)* *r+c|jDcgc] }t|}}tjt}|j t jD]}t|dd}|t|jdd}|, t||vrn,t|dd}|t|jdd}|n|}:|jt|tr|jd}||j|jt |_|jD]p}||}|jD]}||vs|||z }|r t!|gng||<t!||xs |jg} |jj| r|j t jD cgc]} | jc} } t!| xs |jg|_ycc}wcc} w)N_clockr)rlidrIrJrFrfrrggetattr_ownerrhrrmappend _minperiod _minperiodsmax) rnrqdataids _dminperiodslineiterclkclk2 dlminperiodsl dminperiodx minperiodss r* _periodsetzStrategy._periodsets(, 32d833"..t4 ++L,@,@A :H(Hd3C{hoox>;c7g%sHd3<"3::x>D<{#~.iil   $ $X%8%8 9? :B 6JJ 0D(-LZZ 4 $ LO3L 4 9E#l"3!4"L \$/DDOO3DEJ    # #J /# 0*$(#6#6|7K7K#L MaQ\\ M j=T__,=>w4t Ns G%/G*c:|jj|y)z Unlike the other _addxxx functions this one receives an instance because the writer works at cerebro level and is only passed to the strategy to simplify the logic N)rSrz)rnwriters r* _addwriterzStrategy._addwriters F#r+c||i|yr5)rnindclsindargs indkwargss r* _addindicatorzStrategy._addindicators%9%r+cL||i|}|jj||S)aLike _addanalyzer but meant for observers (or other entities) which rely on the output of an analyzer for the data. These analyzers have not been added by the user and are kept separate from the main analyzers Returns the created analyzer rTrz)rnanclsanargsankwargsanalyzers r*_addanalyzer_slavezStrategy._addanalyzer_slaves,&-H- $$X.r+c4|jj|Sr5r)rnidxs r*_getanalyzer_slavezStrategy._getanalyzer_slaves$$++C00r+c|jddxs|jj}t|j|}|t |xsdz }||i|}|j j||y)N_name)r"rZlowernextrRstrrOrz)rnrrrannamensuffixrs r* _addanalyzerzStrategy._addanalyzersmgr*Denn.B.B.Dt}}V,-#gm$$&-H- h/r+c|jdd}|s|jj}|sNtt j |j |}||i|}|jj||yt|j|tt|j|}|j D]} || g|i|}|j|!y)Nobsnamer) r"rZrrFrPchainrlrMrzsetattrrx) rnmultiobsclsobsargs obskwargsrnewargsobsrrqs r* _addobserverzStrategy._addobservers-- 2.oo++-G9??4::w?@G'/Y/C JJ  c7 +  GTV, DJJ (JJ D5595C HHSM r+cttj|jtt|j }t |x|_}|Sr5)r operatorsubr|lenrlr} _minperstatus)rndlens minperstatuss r*_getminperstatuszStrategy._getminperstatus s<HLL$"2"2CTZZ4HI,/J6\r+cyr5rrns r* prenext_openzStrategy.prenext_open r+c$|jyr5) next_openrs r*nextstart_openzStrategy.nextstart_opens  r+cyr5rrs r*rzStrategy.next_openrr+c|j}|dkr|jy|dk(r|jy|jyNrrrrrrnrs r*_oncepost_openzStrategy._oncepost_open?)) !  NN  Q     !    r+c\|jtjD]4}t|jt|kDs%|j 6|j r|j n|j||jjd<|j|j}|dkr|jn&|dk(r|jn|j|j|d|j!|d|j#y)NrT)once)rfrrgrrvadvance_oldsyncforwardrmra_notifyrr nextstartprenext_next_analyzers_next_observersclear)rndt indicatorrs r* _oncepostzStrategy._oncepost$s,,\-A-AB $I9##$s9~5!!# $ == LLN LLN!# A ,,. !  IIK Q  NN  LLN \5 \5 r+c|jrGtt|}t d|j D|j jd<|S|j Dcgc] }t|}}tdt|j|Dr|jt d|j D|j jd<||_ t|Scc}w)Nc3PK|]}t|r|jd ywrNrra.0ds r* z'Strategy._clk_update..Cs()H-.A*+A)H$&rc3,K|] \}}||kDywr5r)rrnls r*rz'Strategy._clk_update..Hs>%!RrAv>c3PK|]}t|r|jd ywrrrs r*rz'Strategy._clk_update..Ks(%D)*CF&'ZZ]%Dr) rr#r- _clk_updater}rlrmraranyzip_dlensr)rnclk_lenrnewdlensr)s r*rzStrategy._clk_update@s ==Hd79G%()H26**)H&HDJJ   "N$(JJ/qCF// >3t{{H#=> > LLN!$%D.2jj%D"D A 4y0s#C2c|j}|dkr|jy|dk(r|jy|jyrrrs r* _next_openzStrategy._next_openQrr+ctt| |j}|j ||j ||j yr5)r#r-_nextrrrr)rnrr)s r*rzStrategy._nextZsC h#%,,.  \* \* r+c |jtjD]}|jD]>}|dkr|j |dk(r|j /|j @|rt|t|kDr-|jr|jn|j|dkr|j|dk(r|jt|s|j|j yr)rfrObsType _analyzersr _nextstart_prenextrrrrrrr)rnrrobserverrs r*rzStrategy._next_observerscs++L,@,@A !H$// (!#NN$!Q&'')%%'  (t9s8},}} ((* ((*!#MMO!Q&&&(]$$& / !r+c|jD]>}|dkr|j|dk(r|j/|j@yr)rOrrr)rnrrrs r*rzStrategy._next_analyzers}sG $Ha "##%!!#  $r+cN|jjj|yr5)rmra_settz)rntzs r*rzStrategy._settzs ""2&r+c|jtj|j|jD]}|j |j D],}t|ts|g}|D]}|j .|j|jDcgc] }t|c}|_ t|_|jycc}wr5)rrPrrOrT_startrNrhrF_stage2rlrrrrstart)rnrrorqs r*rzStrategy._starts !8M8MN H OO  >> Cc4(e      -1ZZ8Ts4y8 # 9s)Ccy)z;Called right before the backtesting is about to be started.Nrrs r*rzStrategy.start r+c|g|_tj|j|j }|jj t d|t}|jD]q}|jjxs|jj}|j||jd|j |js|S)Nc|jSr5)csv)rs r*z+Strategy.getwriterheaders..s quur+r) indobscsvrPrgetindicators_lines getobserversextendrrFriplotnamer)rZrzgetlinealiases)rnindobsheadersiocsvr&s r*getwriterheaderszStrategy.getwriterheaderss  $ $ &(9(9(;= f_f=>&^^ 3E>>**Feoo.F.FD NN4 NN5 ! NN5//1 2  3 r+ct}|jD]}|jjxs|jj }|j |t|}|j ||r5|jtd|jj|jdg|jjz|S)Nc |dSrr)rs r*rz*Strategy.getwritervalues..s AaDr+r) rFrrirr)rZrzrrr rmitersizesize)rnvaluesrr&lios r*getwritervalueszStrategy.getwritervaluess^^ 9E>>**Feoo.F.FD MM$ e*C MM#  c.%++2F2F2HIJ rdU[[%5%5%778 9 r+ct}|jj|d<d|jgd|j gg}|D]s\}}||}|D]d}|j j }|jjxsd||_ |jjxsd||_ fu|j}|jj|j_|jj!|j_|j$j'D]C\} } | jjxsd|| _ | j)|| _E|S)NParams Indicators Observers)rp _getkwargsrrr)rZrmrLinesr AnalyzersrB startingcashValueBegingetvalueEndrOgetitems get_analysisAnalysis) rnwrinfosectionssectname sectitemssinfoitemitnameainfoanamers r* getwriterinfozStrategy.getwriterinfosc "66,,.x4335 6 $++- .  $, C Hi8$E! C00&*jj&?&?&A&ITf #'+vv'8'8':'Bdf $ C C  !KK44 ++..0  $~~668 JJ**   I\\),U]]; y%--$($8$8:E   e $rNE^^//1, 5E}|| U"\\"[[".."--"YY&+nn 6>>''..tyy/?@"tyy'78||>>!y%--,0,@,@BE%%e, U"\\"[[".."--"YY&+nn 6>>''..tyy/?@"tyy'78##**499U+;<NN499U#34Y, 5\  LL'L : r+c|jjjr|}|}n|j}|j}|D]x}|j |j k7s |jr|j|tj|j|jD]}|j|z|D]S}|j|tj|j|jD]}|j|U|ry|j j#}|j j%} |j j&} |j j(} |j+|| |j-|| | | tj|j|jD](}|j/|| |j1|| | | *yr5)r:rrLrHrLexectype Historical histnotifyrrPrrOrT _notify_orderr! _notify_traderBgetcashr fundvalue fundsharesnotify_cashvalue notify_fund_notify_cashvalue _notify_fund) rnr6r7 procorders proctradesrKrrOcashvaluerYrZs r*rzStrategy._notifyAs <<>> % %!J J,,J,,J .E~~!1!11U5E5E!!%(%OODNN,0,A,AC .&&u- . .  .E   e $%OODNN,0,A,AC .&&u- . .  {{""$ $$&KK)) [[++  dE* ui<!8M8MN FH  & &tU 3  ! !$y* E Fr+Nc T|jj| |||||||||| d| d | S)a **Note**: can be called during ``__init__`` or ``start`` Schedules a timer to invoke either a specified callback or the ``notify_timer`` of one or more strategies. 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. - ``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 F) ownerwhenoffsetrepeatweekdays weekcarry monthdays monthcarryallowtzdatastratscheat)r: _add_timer) rnrerfrgrhrirjrkrlrmror=r>s r* add_timerzStrategy.add_timergsLx't||&&  T&J%u    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. Nr)rntimerrer=r>s r* notify_timerzStrategy.notify_timers r+cy)zX Receives the current fund value, value status of the strategy's broker Nr)rnrarbs r*r[zStrategy.notify_cashvalue r+cy)zM Receives the current cash, value, fundvalue and fund shares Nr)rnrarbrYsharess r*r\zStrategy.notify_fundrvr+cy)zK Receives an order whenever there has been a change in one NrrnrKs r*rzStrategy.notify_orderrvr+cy)zJ Receives a trade whenever there has been a change in one Nr)rnrOs r*r!zStrategy.notify_tradervr+cy)z-Receives a notification from a store providerNr)rnmsgr=r>s r* notify_storezStrategy.notify_storerr+cy)z!Receives a notification from dataNr)rnrqstatusr=r>s r* notify_datazStrategy.notify_datarr+c@t|jjS)z; Returns a list of the existing data names )r r9 datasbynamers r* getdatanameszStrategy.getdatanamessDHH(())r+c4|jj|S)zN Returns a given data by name using the environment (cerebro) )r9r)rnr&s r* getdatabynamezStrategy.getdatabynamesxx##D))r+c:|jj|y)zCancels the order in the brokerN)rBcancelrzs r*rzStrategy.cancels 5!r+c  t|tr|j|}||n|jd}||n|j |d}|r3|j j ||ft|||||||| | | | d | Sy)a-Create a buy (long) order and send it to the broker - ``data`` (default: ``None``) For which data the order has to be created. If ``None`` then the first data in the system, ``self.datas[0] or self.data0`` (aka ``self.data``) will be used - ``size`` (default: ``None``) Size to use (positive) of units of data to use for the order. If ``None`` the ``sizer`` instance retrieved via ``getsizer`` will be used to determine the size. - ``price`` (default: ``None``) Price to use (live brokers may place restrictions on the actual format if it does not comply to minimum tick size requirements) ``None`` is valid for ``Market`` and ``Close`` orders (the market determines the price) For ``Limit``, ``Stop`` and ``StopLimit`` orders this value determines the trigger point (in the case of ``Limit`` the trigger is obviously at which price the order should be matched) - ``plimit`` (default: ``None``) Only applicable to ``StopLimit`` orders. This is the price at which to set the implicit *Limit* order, once the *Stop* has been triggered (for which ``price`` has been used) - ``trailamount`` (default: ``None``) If the order type is StopTrail or StopTrailLimit, this is an absolute amount which determines the distance to the price (below for a Sell order and above for a buy order) to keep the trailing stop - ``trailpercent`` (default: ``None``) If the order type is StopTrail or StopTrailLimit, this is a percentage amount which determines the distance to the price (below for a Sell order and above for a buy order) to keep the trailing stop (if ``trailamount`` is also specified it will be used) - ``exectype`` (default: ``None``) Possible values: - ``Order.Market`` or ``None``. A market order will be executed with the next available price. In backtesting it will be the opening price of the next bar - ``Order.Limit``. An order which can only be executed at the given ``price`` or better - ``Order.Stop``. An order which is triggered at ``price`` and executed like an ``Order.Market`` order - ``Order.StopLimit``. An order which is triggered at ``price`` and executed as an implicit *Limit* order with price given by ``pricelimit`` - ``Order.Close``. An order which can only be executed with the closing price of the session (usually during a closing auction) - ``Order.StopTrail``. An order which is triggered at ``price`` minus ``trailamount`` (or ``trailpercent``) and which is updated if the price moves away from the stop - ``Order.StopTrailLimit``. An order which is triggered at ``price`` minus ``trailamount`` (or ``trailpercent``) and which is updated if the price moves away from the stop - ``valid`` (default: ``None``) Possible values: - ``None``: this generates an order that will not expire (aka *Good till cancel*) and remain in the market until matched or canceled. In reality brokers tend to impose a temporal limit, but this is usually so far away in time to consider it as not expiring - ``datetime.datetime`` or ``datetime.date`` instance: the date will be used to generate an order valid until the given datetime (aka *good till date*) - ``Order.DAY`` or ``0`` or ``timedelta()``: a day valid until the *End of the Session* (aka *day* order) will be generated - ``numeric value``: This is assumed to be a value corresponding to a datetime in ``matplotlib`` coding (the one used by ``backtrader``) and will used to generate an order valid until that time (*good till date*) - ``tradeid`` (default: ``0``) This is an internal value applied by ``backtrader`` to keep track of overlapping trades on the same asset. This ``tradeid`` is sent back to the *strategy* when notifying changes to the status of the orders. - ``oco`` (default: ``None``) Another ``order`` instance. This order will become part of an OCO (Order Cancel Others) group. The execution of one of the orders, immediately cancels all others in the same group - ``parent`` (default: ``None``) Controls the relationship of a group of orders, for example a buy which is bracketed by a high-side limit sell and a low side stop sell. The high/low side orders remain inactive until the parent order has been either executed (they become active) or is canceled/expires (the children are also canceled) bracket orders have the same size - ``transmit`` (default: ``True``) Indicates if the order has to be **transmitted**, ie: not only placed in the broker but also issued. This is meant for example to control bracket orders, in which one disables the transmission for the parent and 1st set of children and activates it for the last children, which triggers the full placement of all bracket orders. - ``**kwargs``: additional broker implementations may support extra parameters. ``backtrader`` will pass the *kwargs* down to the created order objects Example: if the 4 order execution types directly supported by ``backtrader`` are not enough, in the case of for example *Interactive Brokers* the following could be passed as *kwargs*:: orderType='LIT', lmtPrice=10.0, auxPrice=9.8 This would override the settings created by ``backtrader`` and generate a ``LIMIT IF TOUCHED`` order with a *touched* price of 9.8 and a *limit* price of 10.0. Returns: - the submitted order NrTisbuy r rAplimitrSvalidr8oco trailamount trailpercentparenttransmit)rhrrrl getsizingrBbuyabsrnrqr rArrSrr8rrrrrr>s r*rz Strategy.buysp dL )%%d+D'tTZZ]'tT^^D^-M "4;;??dYeF!S'l    r+c  t|tr|j|}||n|jd}||n|j |d}|r3|j j ||ft|||||||| | | | d | Sy)z To create a selll (short) order and send it to the broker See the documentation for ``buy`` for an explanation of the parameters Returns: the submitted order NrFrr)rhrrrlrrBsellrrs r*rz Strategy.sells dL )%%d+D'tTZZ]'tT^^D^-N #4;;##dYeF!S'l    r+c 6t|tr|j|}n| |j}|j ||j j }t||n|}|dkDr|jd||d|S|dkr|jd||d|Sy)aI Counters a long/short position closing it See the documentation for ``buy`` for an explanation of the parameters Note: - ``size``: automatically calculated from the existing position if not provided (default: ``None``) by the caller Returns: the submitted order Nrrqr r) rhrrrq getpositionrBr rrr)rnrqr r>possizes r*closezStrategy.closes dL )%%d+D \99D""45::4+49 Q;499<$Tkargsrostopolimits r* buy_bracketzStrategy.buy_bracketsSR$eFX '!,<I  U V%-B(d2Bj DHH u   d)h$g7E LL " LL E(O )T 1E* FFE&MDII&&EE  d*y$g7E LL # LL E(O $E* FFE&MTYY''FF5&!!r+c Bt|||||||||  }|j| |j||duxr| du|d<|jdi|}| `t|| | ||}|j| |j|||d<|du|d<|j|d<|jdi|}nd}|^t|||||}|j||j|||d<d|d<|j|d<|jdi|}nd}|||gS) aT Create a bracket order group (low side - buy order - high side). The default behavior is as follows: - Issue a **sell** order with execution ``Limit`` - Issue a *high side* bracket **buy** order with execution ``Stop`` - Issue a *low side* bracket **buy** order with execution ``Limit``. See ``bracket_buy`` for the meaning of the parameters High/Low Side orders can be suppressed by using: - ``stopexec=None`` to suppress the *high side* - ``limitexec=None`` to suppress the *low side* Returns: - A list containing the 3 orders [order, stop side, limit side] - If high/low orders have been suppressed the return value will still contain 3 orders, but those suppressed will have a value of ``None`` rNrrrr Tr)r]r@rr rrs r* sell_bracketzStrategy.sell_bracketsSF$eFX '!,<I  U V%-B(d2Bj DII    d)h$g7E LL " LL E(O )T 1E* FFE&MDHH%u%EE  d*y$g7E LL # LL E(O $E* FFE&MTXX&&FF5&!!r+c Vt|tr|j|}n| |j}|j ||j j }|s|r|jd||d|S||kDr|jd|||z d|S||kr|jd|||z d|Sy)a Place an order to rebalance a position to have final size of ``target`` The current ``position`` size is taken into account as the start point to achieve ``target`` - If ``target`` > ``pos.size`` -> buy ``target - pos.size`` - If ``target`` < ``pos.size`` -> sell ``pos.size - target`` It returns either: - The generated order or - ``None`` if no order has been issued (``target == position.size``) Nrr) rhrrrqrrBr rrrrnrqtargetr>rs r*order_target_sizezStrategy.order_target_sizes& dL )%%d+D \99D""45::'4::@4g@@ @ g 488GFW,<GG G g 499H$Wv-=HH Hr+c :t|tr|j|}n| |j}|j ||j j }|s|r|jd|||d|S|j j|g}|j j|}||n|jd}||kDr+|j|||z }|jd|||d|S||kr+|j|||z }|jd|||d|Sy)a Place an order to rebalance a position to have final value of ``target`` The current ``value`` is taken into account as the start point to achieve ``target`` - If no ``target`` then close postion on data - If ``target`` > ``value`` then buy on data - If ``target`` < ``value`` then sell on data It returns either: - The generated order or - ``None`` if no order has been issued N)rqr rA)rlrr) rhrrrqrrBr rrgetcommissioninfogetsizerr) rnrqrrAr>rrbr:r s r*order_target_valuezStrategy.order_target_values&* dL )%%d+D \99D""45::'4::M4gUMfM MKK((v(6E{{44T:H#.EDJJqME~''v~>txxLTELVLL%''uv~> tyyMdUMfMMr+c t|tr|j|}n| |j}|j ||j j }||j jz}|jd||d|S)a Place an order to rebalance a position to have final value of ``target`` percentage of current portfolio ``value`` ``target`` is expressed in decimal: ``0.05`` -> ``5%`` It uses ``order_target_value`` to execute the order. Example: - ``target=0.05`` and portfolio value is ``100`` - The ``value`` to be reached is ``0.05 * 100 = 5`` - ``5`` is passed as the ``target`` value to ``order_target_value`` The current ``value`` is taken into account as the start point to achieve ``target`` The ``position.size`` is used to determine if a position is ``long`` / ``short`` - If ``target`` > ``value`` - buy if ``pos.size >= 0`` (Increase a long position) - sell if ``pos.size < 0`` (Increase a short position) - If ``target`` < ``value`` - sell if ``pos.size >= 0`` (Decrease a long position) - buy if ``pos.size < 0`` (Decrease a short position) It returns either: - The generated order or - ``None`` if no order has been issued (``target == position.size``) )rqrr) rhrrrqrrBr rrrs r*order_target_percentzStrategy.order_target_percent2s}L dL )%%d+D \99D""45::$++&&((&t&&JDJ6JJr+cj||n|jd}|xs |j}|j|S)z Returns the current position for a given data in a given broker. If both are None, the main data and the default broker will be used A property ``position`` is also available r)rlrBr)rnrqrBs r*rzStrategy.getpositionbs7'tTZZ]&4;;!!$''r+c|s|jdn|j|}|xs |j}|j|S)z Returns the current position for a given name in a given broker. If both are None, the main data and the default broker will be used A property ``positionbyname`` is also available r)rlrrBr)rnr&rBrqs r*getpositionbynamezStrategy.getpositionbynameps?%)tzz!}d.@.@.F&4;;!!$''r+c:|xs |j}|jS)z Returns the current by data positions directly from the broker If the given ``broker`` is None, the default broker will be used A property ``positions`` is also available )rB positions)rnrBs r* getpositionszStrategy.getpositions~s&4;;r+c|xs |j}|j}tj}t |j j D] \}}||||<|S)z Returns the current by name positions directly from the broker If the given ``broker`` is None, the default broker will be used A property ``positionsbyname`` is also available )rBrrIrr r9r)rnrBr posbynamer&rqs r*getpositionsbynamezStrategy.getpositionsbynamesb&4;;$$ ++- #DHH$8$89 .JD$'oIdO .r+c|.|jtjjy|j||i|yr5)setsizerr7rCrD)rnsizerr=r>s r* _addsizerzStrategy._addsizers6 = MM"))--/ 0 MM%00 1r+cL||_|j||j|S)z9 Replace the default (fixed stake) sizer )rErYrB)rnrs r*rzStrategy.setsizers"  $ $ r+c|jS)z Returns the sizer which is in used if automatic statke calculation is used Also available as ``sizer`` )rErs r*getsizerzStrategy.getsizers{{r+cb||n|jd}|jj||S)ze Return the stake calculated by the sizer instance for the current situation rr)rlrEr)rnrqrs r*rzStrategy.getsizings2 'tTZZ]{{$$T$77r+)rF)F)T) NNNNNNrNNNNT)NNr)NN)Nrr5)NT)QrZr[r\__doc__r StratType_ltyperrrmrkrrrrrrrrrrrrrrrrrrrrrr rr*r-r,r2rrQrra timedeltarqrtr[r\rr!r~rrrrrrrr7OrderLimitStoprrrrrrpropertypositionrpositionbynamerrrpositionsbynamerrrrrr^r_s@r*r-r-kss # #F CH E!*F<?|$& 10$    8" !4$', $ < %% H;T!"$FN,++-6Hh6H6H6J4U bH        * * "*.6:+/"& gR+/7;,0#' <8 $$d4XX^^4 $4r"RXX]]R#rxx~~ l"\!%d4 hhnnD!!%D#bhhmmb $" F"P"H-^.K` ( $H (/0N  &I"12O2  Xx (E8r+r-c2eZdZfdZfdZfdZxZS)MetaSigStrategycd|vr|jd|d<tt|||||}|j|_|S)Nr _next_custom)r"r#rr$ _next_catchr)r%r&r'r(r3r)s r*r$zMetaSigStrategy.__new__sE S="%''&/C OT24ucJ?? r+ctt| |g|i|\}}}tjt |_|jj}||j|_ nt|tr|j||_ nZt|tr|j||_ n3t|t j"r||_ n|j|_ |||fSr5)r#rrArIrJrF_signalsr_datadata0_dtargetrhr rlrrr7LineRoot)r3r?r=r>rr)s r*rAzMetaSigStrategy.dopreinits /3 1$ H H H dF$//5   = JJDM } - JJu-DM | , ..u5DM r{{ +!DM JJDMT6!!r+cztt| |g|i|\}}}|jjD]+\}}}}|j |j ||i|-t|j tj|_ t|j tj|_ t|j tj|_t|j tj|_t|j tj"|_|||fSr5)r#rrXrsignalsrrzboolr7SIGNAL_LONGSHORT _longshort SIGNAL_LONG_long SIGNAL_SHORT_shortSIGNAL_LONGEXIT _longexitSIGNAL_SHORTEXIT _shortexit) r3r?r=r>sigtypesigclssigargs sigkwargsr)s r*rXzMetaSigStrategy.dopostinits /3 24 I$ I& I dF4866>> I /GVWi MM' " ) )&'*GY*G H It}}R-@-@AB$--78 4==9: dmmB,>,>?@t}}R-@-@ABT6!!r+)rZr[r\r$rArXr^r_s@r*rrs "(""r+rcTeZdZdZdgfdddfZfdZdZggffd Zd Zd Z xZ S) SignalStrategyat This subclass of ``Strategy`` is meant to to auto-operate using **signals**. *Signals* are usually indicators and the expected output values: - ``> 0`` is a ``long`` indication - ``< 0`` is a ``short`` indication There are 5 types of *Signals*, broken in 2 groups. **Main Group**: - ``LONGSHORT``: both ``long`` and ``short`` indications from this signal are taken - ``LONG``: - ``long`` indications are taken to go long - ``short`` indications are taken to *close* the long position. But: - If a ``LONGEXIT`` (see below) signal is in the system it will be used to exit the long - If a ``SHORT`` signal is available and no ``LONGEXIT`` is available , it will be used to close a ``long`` before opening a ``short`` - ``SHORT``: - ``short`` indications are taken to go short - ``long`` indications are taken to *close* the short position. But: - If a ``SHORTEXIT`` (see below) signal is in the system it will be used to exit the short - If a ``LONG`` signal is available and no ``SHORTEXIT`` is available , it will be used to close a ``short`` before opening a ``long`` **Exit Group**: This 2 signals are meant to override others and provide criteria for exitins a ``long``/``short`` position - ``LONGEXIT``: ``short`` indications are taken to exit ``long`` positions - ``SHORTEXIT``: ``long`` indications are taken to exit ``short`` positions **Order Issuing** Orders execution type is ``Market`` and validity is ``None`` (*Good until Canceled*) Params: - ``signals`` (default: ``[]``): a list/tuple of lists/tuples that allows the instantiation of the signals and allocation to the right type This parameter is expected to be managed through ``cerebro.add_signal`` - ``_accumulate`` (default: ``False``): allow to enter the market (long/short) even if already in the market - ``_concurrent`` (default: ``False``): allow orders to be issued even if orders are already pending execution - ``_data`` (default: ``None``): if multiple datas are present in the system which is the target for orders. This can be - ``None``: The first data in the system will be used - An ``int``: indicating the data that was inserted at that position - An ``str``: name given to the data when creating it (parameter ``name``) or when adding it cerebro with ``cerebro.adddata(..., name=)`` - A ``data`` instance r) _accumulateF) _concurrentF)rNc8d|_tt|yr5) _sentinelr#rr)rnr)s r*rzSignalStrategy._startLs nd*,r+c@|j|j|yr5)rrz)rnrsignals r* signal_addzSignalStrategy.signal_addPs g%%f-r+c|xs |j}|j0|D]+}||jk(s|jr$d|_ntt|||y)Nr5)rHraliver#rr)rnr6r7r_rKr)s r*rzSignalStrategy._notifySs`3 3 3 >> %# DNN*5;;=%)DN  nd+GW+Mr+c^|jt|dr|jyy)Nr) _next_signalhasattrrrs r*rzSignalStrategy._next_catch^s)  4 (     )r+c |j|jjsy|j}dgg}t d|t j xs|D}t d|t j xs|D}t d|t jxs|D}t d|t jxs|D}t d|t jxs|D}|xs|xs|}t d|t jxs|D} t d|t jxs|D} t d |t jxs|D} | xs| xs| } t d |t jxs|D} t d |t jxs|D}t d |t jxs|D}| xs|xs|}t d |t j xs|D}t d|t j"xs|D}t d|t j$xs|D}|xs|xs|}|j& xr| }|j( xr|}t d|t jxs|D}t d|t jxs|D}t d|t jxs|D}|xs|xs|}t d|t jxs|D}t d|t jxs|D}t d|t jxs|D}|xs|xs|}|j& xr|}|j( xr|}|j+|j,j.}|sK|s|r!|j1|j,|_y|s| r!|j3|j,|_yy|dkDr|s|s|s|r|j5|j,|s|r |j3|j,|_|s|r8|jj6r!|j1|j,|_yyy|dkr|s|s|s|r|j5|j,|s|r |j1|j,|_|s| r8|jj6r!|j3|j,|_yyyy)Nrc3,K|] }|ddkDywrrNrrrs r*rz.SignalStrategy._next_signal..kMQadSjMrc3,K|] }|ddkywrrrs r*rz.SignalStrategy._next_signal..lNaqtczNrc3,K|] }|ddkDywrrrs r*rz.SignalStrategy._next_signal..nsIaqtczIrc3,K|] }|ddkywrrrs r*rz.SignalStrategy._next_signal..osMaqtczMrc3&K|] }|d ywrrrs r*rz.SignalStrategy._next_signal..psGqtGc3,K|] }|ddkywrrrs r*rz.SignalStrategy._next_signal..ssJaqtczJrc3,K|] }|ddkDywrrrs r*rz.SignalStrategy._next_signal..trrc3&K|] }|d ywrrrs r*rz.SignalStrategy._next_signal..usHqtHr c3,K|] }|ddkywrrrs r*rz.SignalStrategy._next_signal..xsJ1AaD3JJrc3,K|] }|ddkDywrrrs r*rz.SignalStrategy._next_signal..ysN1AaD3JNrc3&K|] }|d ywrrrs r*rz.SignalStrategy._next_signal..zsHQAaDHr c3,K|] }|ddkDywrrrs r*rz.SignalStrategy._next_signal..}sK1AaD3JKrc3,K|] }|ddkywrrrs r*rz.SignalStrategy._next_signal..~sO1AaD3JOrc3&K|] }|d ywrrrs r*rz.SignalStrategy._next_signal..sIQAaDIr c3,K|] }|ddkywrrrs r*rz.SignalStrategy._next_signal..sHQadSjHrc3,K|] }|ddkDywrrrs r*rz.SignalStrategy._next_signal..sLQadSjLrc3&K|] }|d ywrrrs r*rz.SignalStrategy._next_signal..sFqadFr c3,K|] }|ddkDywrrrs r*rz.SignalStrategy._next_signal..sIQadSjIrc3,K|] }|ddkywrrrs r*rz.SignalStrategy._next_signal..rrc3&K|] }|d ywrrrs r*rz.SignalStrategy._next_signal..sGqadGr r)rrrrallr7rrSIGNAL_LONG_INVSIGNAL_LONG_ANYrSIGNAL_SHORT_INVSIGNAL_SHORT_ANYrSIGNAL_LONGEXIT_INVSIGNAL_LONGEXIT_ANYrSIGNAL_SHORTEXIT_INVSIGNAL_SHORTEXIT_ANYrrrrr rrrr) rnsigsnosigls_longls_shortl_enter0l_enter1l_enter2l_enters_enter0s_enter1s_enter2s_enterl_ex0l_ex1l_ex2l_exits_ex0s_ex1s_ex2s_exitl_revs_revl_leav0l_leav1l_leav2l_leaves_leav0s_leav1s_leav2s_leaver s r*rzSignalStrategy._next_signalcs| >> %dff.@.@ }}M$r/B/B*C*LuMMN40C0C+D+MNNI4+?+H5IIM40B0B+C+LuMMGT"*<*<%=%FGG2h2(J4+@+IEJJN40C0C+D+MNNHT"*=*=%>%G%HH2h2(JR-?-?(@(IEJJNR-C-C(D(MNNH$r'='=">"G%HH(%(5KR-@-@(A(JUKKOR-D-D(E(NOOI$r'>'>"?"H5II(%(5NN".wOO#/H$r~~*>*G%HHL$r/A/A*B*KeLLFD););$<$EFF/W/I$r*?*H5IIM$r/B/B*C*LuMMGD)<)<$=$FGG/W/nn$0oo%1' .33'!%$--!8W!%4==!9%AX6Ug 4==)5!%4==!9'66%%%)XXdmm%r+r), __future__rrrrrIrFrainspectrPr utils.py3rr r r r r rrr backtraderr7 lineiteratorrrlinerootr lineseriesrmetabaserrrOrutilsrrrr)rr-rrrr+r*rLs*** CCC4 &/==="<))="@R8~lL9R8j*1"h((1"hB>^OX>B>r+