'igdZddlmZmZmZmZddlZddlZddlZddl m Z ddl Z ddl m Z mZmZddlmZmZmZddlmZdd lmZmZed ZGd d eZGd dej8ZGddeZGddeeeZ ddZ!dZ"Gdde Z#Gdde Z$Gdde Z%Gdde Z&y)z .. module:: linebuffer Classes that hold the buffer for a *line* and can operate on it with appends, forwarding, rewinding, resetting and other .. moduleauthor:: Daniel Rodriguez )absolute_importdivisionprint_functionunicode_literalsN)islice)rangewith_metaclass string_types)LineRoot LineSingle LineMultiple)metabase)num2datetime2numNaNcteZdZdZd\ZZdZdZd1dZe eeZ dZ d2dZ d Z d Zd Zd Zd ZddZd3dZddZdZd3dZdZedfdZd4dZd5dZd5dZedfdZdZd6dZdZ dZ!d3dZ"e"Z#d7d Z$d8d!Z%d7d"Z&d#Z'd9d$Z(d9d%Z)d9d&Z*d3d'Z+d3d(Z,d3d)Z-d3d*Z.d3d+Z/d3d,Z0d3d-Z1d3d.Z2d3d/Z3d3d0Z4y): LineBufferaD LineBuffer defines an interface to an "array.array" (or list) in which index 0 points to the item which is active for input and output. Positive indices fetch values from the past (left hand side) Negative indices fetch values from the future (if the array has been extended on the right hand side) With this behavior no index has to be passed around to entities which have to work with the current value produced by other entities: the value is always reachable at "0". Likewise storing the current value produced by "self" is done at 0. Additional operations to move the pointer (home, forward, extend, rewind, advance getzero) are provided The class can also hold "bindings" to other LineBuffers. When a value is set in this class it will also be set in the binding. )rrc|g|_|j|_t|_|j d|_yN)lines UnBoundedmodelistbindingsreset_tzselfs S/var/www/app/trading-bot/venv/lib/python3.12/site-packages/backtrader/linebuffer.py__init__zLineBuffer.__init__Ks/V NN   c|jSr)_idxrs r get_idxzLineBuffer.get_idxRs yyr"c|j|jk(r$|s|j|jkr||_yy||_yr)rQBufferr$lenmark)ridxforces r set_idxzLineBuffer.set_idxUs; 99 $ DLL0 1DIr"c(|j|jk(r:tj|j|j z|_d|_n*t j td|_d|_d|_ d|_ d|_ y)z> Resets the internal buffer structure and the indices )maxlenTdFrN) rr' collectionsdequer- extrasizearray useislicestrlencountr) extensionrs r rzLineBuffer.resetfsl 99 $ %**$++2NODJ!DNSX.DJ"DN r"rc|j|_|j|_||_|j|j z |_|j yr)r'r _minperiodr-r2r(r)rsavememr2s r qbufferzLineBuffer.qbufferys?LL oo "{{$..&89  r"cgSrrs r getindicatorszLineBuffer.getindicators r"c|j|jk7s|j|k\ry||_|j|j z |_|j y)aThe linebuffer must guarantee the minimum requested size to be available. In non-dqbuffer mode, this is always true (of course until data is filled at the beginning, there are less values, but minperiod in the framework should account for this. In dqbuffer mode the buffer has to be adjusted for this if currently less than requested N)rr'r-r2r(rrsizes r minbufferzLineBuffer.minbuffersI 99 $ t(;  {{$..&89  r"c|jSr)r6rs r __len__zLineBuffer.__len__s }}r"cFt|j|jz S)a Real data that can be currently held in the internal buffer The internal buffer can be longer than the actual stored data to allow for "lookahead" operations. The real amount of data that is held/can be held in the buffer is returned )lenr3r7rs r buflenzLineBuffer.buflens4:://r"c:|j|j|zSr)r3r)ragos r __getitem__zLineBuffer.__getitem__szz$((S.))r"rc |jrG|j|z|z dz}|j|zdz}tt|j||S|j|j|z|z dz|j|zdzS)a Returns a slice of the array relative to *ago* Keyword Args: ago (int): Point of the array to which size will be added to return the slice size(int): size of the slice to return, can be positive or negative If size is positive *ago* will mark the end of the iterable and vice versa if size is negative Returns: A slice of the underlying buffer r)r4r)rrr3)rrKrBstartends r getzLineBuffer.gets| >>HHsNT)A-E((S.1$Ctzz5#67 7zz$((S.4/!3DHHsNQ4FGGr"c |j|S)a5 Returns a single value of the array relative to the real zero of the buffer Keyword Args: idx (int): Where to start relative to the real start of the buffer size(int): size of the slice to return Returns: A slice of the underlying buffer )r3)rr)s r getzerovalzLineBuffer.getzerovalszz#r"c|jr#tt|j|||zS|j|||zS)a& Returns a slice of the array relative to the real zero of the buffer Keyword Args: idx (int): Where to start relative to the real start of the buffer size(int): size of the slice to return Returns: A slice of the underlying buffer r4rrr3rr)rBs r getzerozLineBuffer.getzeros< >>tzz3d ;< <zz#cDj))r"ch||j|j|z<|jD]}|||< y)z Sets a value at position "ago" and executes any associated bindings Keyword Args: ago (int): Point of the array to which size will be added to return the slice value (variable): value to be set Nr3r)r)rrKvaluebindings r __setitem__zLineBuffer.__setitem__6&+ 488c>"}} !G GCL !r"ch||j|j|z<|jD]}|||< y)z Sets a value at position "ago" and executes any associated bindings Keyword Args: value (variable): value to be set ago (int): Point of the array to which size will be added to return the slice NrX)rrYrKrZs r setzLineBuffer.setr\r"c d|_d|_y)z Rewinds the logical index to the beginning The underlying buffer remains untouched and the actual len can be found out with buflen r/rNr)r6rs r homezLineBuffer.homes  r"c|xj|z c_|xj|z c_t|D]}|jj |y)z Moves the logical index foward and enlarges the buffer as much as needed Keyword Args: value (variable): value to be set in new positins size (int): How many extra positions to enlarge the buffer N)r)r6r r3appendrrYrBis r forwardzLineBuffer.forwardsE D  t %A JJ  e $ %r"c|j|j|z ||xj|zc_t|D]}|jj y)z Moves the logical index backwards and reduces the buffer as much as needed Keyword Args: size (int): How many extra positions to rewind and reduce the buffer )r*N)r+r$r6r r3pop)rrBr*res r backwardszLineBuffer.backwardssL TYY%U 3  t A JJNN  r"cX|xj|zc_|xj|zc_yrr`rAs r rewindzLineBuffer.rewinds D  r"cX|xj|z c_|xj|z c_y)z Advances the logical index without touching the underlying buffer Keyword Args: size (int): How many extra positions to move forward Nr`rAs r advancezLineBuffer.advances D  r"c|xj|z c_t|D]}|jj|y)ad Extends the underlying array with positions that the index will not reach Keyword Args: value (variable): value to be set in new positins size (int): How many extra positions to enlarge the buffer The purpose is to allow for lookahead operations or to be able to set values in the buffer "future" N)r7r r3rcrds r extendzLineBuffer.extends7 $t %A JJ  e $ %r"cp|jj||j|jy)z Adds another line binding Keyword Args: binding (LineBuffer): another line that must be set when this line becomes a value N)rrcupdateminperiodr9)rrZs r addbindingzLineBuffer.addbinding,s* W% 0r"Nc@|j||xs t|S)a Returns a slice of the array relative to the real zero of the buffer Keyword Args: idx (int): Where to start relative to the real start of the buffer size(int): size of the slice to return This is a variant of getzero which unless told otherwise returns the entire buffer, which is usually the idea behind plottint (all must plotted) Returns: A slice of the underlying buffer )rVrGrUs r plotzLineBuffer.plot8s||C!2T33r"cx|jr tt|j||S|j||SrrTrrNrOs r plotrangezLineBuffer.plotrangeHs2 >>tzz5#67 7zz%$$r"c|j}|j}|jD]}|d||jd|y)zC Executes the bindings when running in "once" mode rN)r3rHr)rlarrayblenrZs r oncebindingzLineBuffer.oncebindingNsA{{}}} 3G$*1TNGMM!D ! 3r"ct|tr!t|jj|}n|jj|}|j ||S)zW Stores a binding to another line. "binding" can be an index or a name ) isinstancer getattr_ownerrrr)rrZlines r bind2lineszLineBuffer.bind2linesWsI g| ,4;;,,g6D;;$$W-D  r"c\ddlm}|t|tr |||St ||S)aReturns either a delayed verison of itself in the form of a LineDelay object or a timeframe adapting version with regards to a ago Param: ago (default: None) If ago is None or an instance of LineRoot (a lines object) the returned valued is a LineCoupler instance If ago is anything else, it is assumed to be an int and a LineDelay object will be returned r) LineCoupler) lineiteratorrr}r LineDelay)rrKrs r __call__zLineBuffer.__call__fs/ . ;*S(3tS) )s##r"c"t|||||S)N)r _ownerskip)LinesOperation)rother operationrrs r _makeoperationzLineBuffer._makeoperationxsdE9)35 5r"ct|||S)N)r)LineOwnOperation)rrrs r _makeoperationownzLineBuffer._makeoperationown|siJGGr"c||_yr)r)rtzs r _settzzLineBuffer._settzs r"cnt|j|j|z|xs |j|SN)rnaive)rr3r)rrrKrrs r datetimezLineBuffer.datetimes/ 488c>2>8 8r"ct|j|j|z|xs |j|j Sr)rr3r)rdaters r rzLineBuffer.date6 488c>2>88< ?r"ct|j|j|z|xs |j|j Sr)rr3r)rtimers r rzLineBuffer.timerr"c`tj|j|j|zS)z; return numeric date part of datetimefloat )mathtruncr3r)rJs r dtz LineBuffer.dts$zz$**TXX^455r"cftj|j|j|zdS)z? return raw numeric time part of datetimefloat r)rmodfr3r)rJs r tm_rawzLineBuffer.tm_raws)yyDHHsN34Q77r"cztt|j|j|zj Sz; return numeric time part of datetimefloat )rrr3r)rrJs r tmz LineBuffer.tms.DHHsN!;<AACDDr"cz|j|j|z}tj|\}}|||zkSrr3r)rrrrrKdtimerrs r tm_ltzLineBuffer.tm_lt; 488c>*5!BU ##r"cz|j|j|z}tj|\}}|||zkSrrrs r tm_lezLineBuffer.tm_le; 488c>*5!Be$$r"cz|j|j|z}tj|\}}|||zk(Srrrs r tm_eqzLineBuffer.tm_eqrr"cz|j|j|z}tj|\}}|||zkDSrrrs r tm_gtzLineBuffer.tm_gtrr"cz|j|j|z}tj|\}}|||zk\Srrrs r tm_gezLineBuffer.tm_gerr"cRt|j|j|z|zSz Returns the given ``tm`` in the frame of the (ago bars) datatime. Useful for external comparisons to avoid precision errors )intr3r)rrrKs r tm2dtimezLineBuffer.tm2dtimes% 4::dhhn-.33r"cdtt|j|j|z|zSr)rrr3r)rs r tm2datetimezLineBuffer.tm2datetimes* DJJtxx#~67"<==r"F)rrr)rF)r)rNr)FN)rNT)5__name__ __module__ __qualname____doc__rr'r!r%r+propertyr)rr;r>rCrErHrLrPrRrVr[r^raNANrfrirkrmrorrrtrwr{r bind2linerrrrrrrrrrrrrrrrrr=r"r rr2s, Iw  7G $C&$0*H*  * ! ! a % Q % 14 % 3 I$$5H8??6 8E $ % % $ %4>r"rcheZdZdZeZdZedZedZ fdZ fdZ fdZ xZ S)MetaLineActionsa. Metaclass for Lineactions Scans the instance before init for LineBuffer (or parentclass LineSingle) instances to calculate the minperiod for this instance postinit it registers the instance to the owner (remember that owner has been found in the base Metaclass for LineRoot) Fc"t|_yr)dict_acache)clss r cleancachezMetaLineActions.cleancaches f r"c||_yr) _acacheuse)ronoffs r usecachezMetaLineActions.usecaches r"cb|jstt||i|S|t |t |j f} |j |S#t$rtt||i|cYSt$rYnwxYwtt||i|}|j j||Sr) rsuperrrtupleitemsr TypeErrorKeyError setdefault)rargskwargsckey_obj __class__s r rzMetaLineActions.__call__s~~#7HH HU4[% "78 ;;t$ $ I#7HH H   _c3TDVD{{%%dD11sAA?4A?>A?c>tt| |g|i|\}}}|j|_t |dt r |d|_|Dcgc]}t |t s|c}|_|Dcgc]}t |ts|j!}}|Dcgc]"}t |ts|jd$}}||Dcgc]}|jc}z }t|xsdg}|j||||fScc}wcc}wcc}wcc}w)Nrr)rr dopreinitr_clockr}r _datasr r9rrmaxrq) rrrrx _minperiodsmlinesr9rs r rzMetaLineActions.dopreinits  /3 1$ H H H dFkk d1gx (q'DK#'BQ*Q*AqB .2OZ:5Nq||O O&*JjL.I!''!*JJf5 55 +,  Z(T6!!CPJ5s*D %D 5D DD5D Dcztt| |g|i|\}}}|jj ||||fSr)rr dopostinitr addindicator)rrrrrs r rzMetaLineActions.dopostinit1sH /3 24 I$ I& I dF   &T6!!r")rrrrrrr classmethodrrrrr __classcell__rs@r rrsPfGJ2 "2""r"rc(eZdZdZdZedZy) PseudoArrayc||_yrwrapped)rrs r r!zPseudoArray.__init__<s  r"c|jSrr)rkeys r rLzPseudoArray.__getitem__?s ||r"c|Srr=rs r r3zPseudoArray.arrayBs r"N)rrrr!rLrr3r=r"r rr;s r"rc^eZdZdZej ZdZdfd Ze dZ dZ dZ xZ S) LineActionsa  Base class derived from LineBuffer intented to defined the minimum interface to make it compatible with a LineIterator by providing operational _next and _once interfaces. The metaclass does the dirty job of calculating minperiods and registering cgSrr=rs r r>zLineActions.getindicatorsRr?r"ctt| ||jD]}|j |j  y)N)r:rB)rrr;rrCr9)rr:datars r r;zLineActions.qbufferUs: k4((9KK 1D NNN 0 1r"c~t|tr!t|ts|jd}|St |}|SNr)r}r r rr)objs r arrayizezLineActions.arrayizeZs; c8 $c:.iil c"C r"c t|j}|t|kDr|j||jkDr|j y||jk(r|j y|j yr)rGrrfr9next nextstartprenext)r clock_lens r _nextzLineActions._nextdsY $ s4y LLN t & IIK $// ) NN  LLNr"c||j|jj|j|j d|j dz |j |j dz |j |j|j |j|jy)Nrrr) rfrrHrapreoncer9 oncestartoncer{rs r _oncezLineActions._onceqs| $++,,. /  Q!+, t*DOO< $//4;;=1 r"r)rrrrrIndType_ltyper>r; staticmethodrrrrrs@r rrGs=  F1  r"rc @|dkr t||fi|St||fi|Sr) _LineDelay _LineForward)arKrs r rr|s- ax!S+F++ 3 )& ))r"c*tt|Sr)rr)nums r LineNumrs [% &&r"c.eZdZdZfdZdZdZxZS)r z Takes a LineBuffer (or derived) object and stores the value from "ago" periods effectively delaying the delivery of data ctt| ||_||_|j t |dzyNr)rr r!rrK addminperiodabsrrrKrs r r!z_LineDelay.__init__s6 j$(* #c(Q,'r"c<|j|j|d<yrrrKrs r rz_LineDelay.nexts&&"Qr"c|j}|jj}|j}t||D] }|||z||<yrr3rrKr rrNrOdstsrcrKres r rz_LineDelay.oncesHjjffllhhuc" "AS\CF "r"rrrrr!rrrrs@r r r s(#"r"r c.eZdZdZfdZdZdZxZS)rzl Takes a LineBuffer (or derived) object and stores the value from "ago" periods from the future ctt| ||_||_||jj kDr,|j ||jj z dzyyr)rrr!rrKr9rrs r r!z_LineForward.__init__sY lD*, "" "   cDFF$5$559 : #r"c>|jd||j <yrrrs r rz_LineForward.nexts&&)dhhYr"c|j}|jj}|j}t||D] }|||||z <yrrrs r rz_LineForward.oncesHjjffllhhuc" "Aq6CCL "r"r rs@r rrs ;$"r"rcHeZdZdZd fd ZdZdZdZdZdZ dZ xZ S) ra  Holds an operation that operates on a two operands. Example: mul It will "next"/traverse the array applying the operation on the two operands and storing the result in self. To optimize the operations and avoid conditional checks the right next/once is chosen using the operation direction (normal or reversed) and the nature of the operands (LineBuffer vs non-LineBuffer) In the "once" operations "map" could be used as in: operated = map(self.operation, srca[start:end], srcb[start:end]) self.array[start:end] = array.array(str(self.typecode), operated) No real execution time benefits were appreciated and therefore the loops have been kept in place for clarity (although the maps are not really unclear here) c0tt| ||_||_||_||_t|t|_ t|tj|_ |j xr |j |_ |r||c|_|_yyr)rrr!rrbrr}rblinerrbtimebfloat)rrr'rrrs r r!zLinesOperation.__init__s{ nd,.":. 8==1 **n7TZZ NDFDF r"c|jr0|j|jd|jd|d<y|jsq|j s-|j|jd|j|d<y|j|jj |j|d<y|j|j|jd|d<yr)r(rrr'rr)rrs r rzLinesOperation.nexts ::nnTVVAYq :DG::..DFF;Q..?QnnTVVTVVAY7DGr"c|jr|j||y|js2|js|j ||y|j ||y|j ||yr)r(_once_oprr) _once_val_op _once_time_op_once_val_op_rrvs r rzLinesOperation.oncesU :: MM% %::!!%-""5#.   s +r"c|j}|jj}|jj}|j}t ||D]}|||||||<yrr3rr'rr rrNrOrsrcasrcbopres r r-zLinesOperation._once_ops\jjvv||vv|| ^^uc" *AQa)CF *r"c|j}|jj}|j}|j}|j}t ||D]*}|t |||j|||<,y)N)r)r3rr'rrr rr) rrNrOrr4r5r6rres r r/zLinesOperation._once_time_opsmjjvv||vv ^^ XXuc" ?AaR0557>CF ?r"c|j}|jj}|j}|j}t ||D]}||||||<yrr2r3s r r.zLinesOperation._once_val_opsTjjvv||vv ^^uc" 'AQ&CF 'r"c|j}|j}|jj}|j}t ||D]}||||||<yrr2r3s r r0zLinesOperation._once_val_op_rsTjjvvvv|| ^^uc" 'Ad1g&CF 'r"r) rrrrr!rrr-r/r.r0rrs@r rrs+( " 8 ,* ?''r"rc.eZdZdZfdZdZdZxZS)rz Holds an operation that operates on a single operand. Example: abs It will "next"/traverse the array applying the operation and storing the result in self cFtt| ||_||_yr)rrr!rr)rrrrs r r!zLineOwnOperation.__init__-s .0"r"cF|j|jd|d<yr)rrrs r rzLineOwnOperation.next3s..+Qr"c|j}|jj}|j}t||D]}|||||<yr)r3rrr )rrNrOrr4r6res r rzLineOwnOperation.once6sHjjvv|| ^^uc" !AQ[CF !r"r rs@r rr&s  ,!r"rr)'r __future__rrrrr3r0r itertoolsrr utils.py3r r r linerootr r rrutilsrrfloatrrrrobjectrrrrr rrrr=r"r rFs* **  ::88% El~>~>BE"j**E"P & 2.*=2j*'""8";"