.dgdZddlmZddlZddlZddlZddlZddlmZm Z ddl m Z ddl m Z mZddlmZmZmZdd lmZdd lmZmZdd lmZmZmZmZmZmZmZmZm Z m!Z!dd l"m#Z#m$Z$dd l%m&Z&m'Z'm(Z(GddeZ)GddeZ*GddeZ+GddeZ,Gdde,Z-GddZ.dddZ/GddZ0dZ1ee1y) a7 reactive API `rx` is a wrapper around a Python object that lets users create reactive expression pipelines by calling existing APIs on an object with dynamic parameters or widgets. An `rx` instance watches what operations are applied to the object and records these on each instance, which are then strung together into a chain. The original input to an `rx` object is stored in a mutable list and can be accessed via the `_obj` property. The shared mutable data structure ensures that all `rx` instances created from the same object can hold a shared reference that can be updated, e.g. via the `.value` property or because the input was itself a reference to some object that can potentially be updated. When an operation is applied to an `rx` instance, it will record the operation and create a new instance using the `_clone` method, e.g. `dfi.head()` first records that the `'head'` attribute is accessed, which is achieved by overriding `__getattribute__`. A new reactive object is returned, which will then record that it is being called, and that new object will be itself called, as `rx` implements `__call__`. `__call__` returns another `rx` instance. To be able to watch all the potential operations that may be applied to an object, `rx` implements: - `__getattribute__`: Watching for attribute accesses - `__call__`: Intercepting both actual calls or method calls if an attribute was previously accessed - `__getitem__`: Intercepting indexing operations - Operators: Implementing all valid operators `__gt__`, `__add__`, etc. - `__array_ufunc__`: Intercepting numpy universal function calls The `rx` object evaluates operations lazily, but whenever the current value is needed the operations are automatically evaluated. Note that even attribute access or tab-completion operations can result in evaluation of the pipeline. This is very useful in a REPL, as this allows inspecting the transformed object at any point of the pipeline, and as such provide correct auto-completion and docstrings. E.g. executing `dfi.A.max?` in an interactive REPL or notebook where it allows returning the docstring of the method being accessed. The actual operations are stored as a dictionary on the `_operation` attribute of each instance. They contain 4 keys: - `fn`: The function to apply (either an actual function or a string indicating the operation is a method on the object) - `args`: Any arguments to supply to the `fn`. - `kwargs`: Any keyword arguments to supply to the `fn`. - `reverse`: If the function is not a method this indicates whether the first arg and the input object should be supplied in reverse order. The `_depth` attribute starts at 0 and is incremented by 1 every time a new `rx` instance is created part of a chain. The root instance in a reactive expression has a `_depth` of 0. A reactive expression can consist of multiple chains, such as `dfi[dfi.A > 1]`, as the `rx` instance is referenced twice in the expression. As a consequence `_depth` is not the total count of `rx` instance creations of a pipeline, it is the count of instances created in the outer chain. In the example, that would be `dfi[]`. Each `rx` instance keeps a reference to the previous instance in the chain and each instance tracks whether its current value is up-to-date via the `_dirty` attribute, which is set to False if any dependency changes. The `_method` attribute is a string that temporarily stores the method/attr accessed on the object, e.g. `_method` is 'head' in `dfi.head()`, until the `rx` instance created in the pipeline is called at which point `_method` is reset to None. In cases such as `dfi.head` or `dfi.A`, `_method` is not (yet) reset to None. At this stage the `rx` instance returned has its `_current` attribute not updated, e.g. `dfi.A._current` is still the original dataframe, not the 'A' series. Keeping `_method` is thus useful for instance to display `dfi.A`, as the evaluation of the object will check whether `_method` is set or not, and if it's set it will use it to compute the object returned, e.g. the series `df.A` or the method `df.head`, and display its repr. ) annotationsN)IterableIterator)partial) FunctionType MethodType)AnyCallableOptional)depends)_display_accessors_reactive_display_objs) Parameter ParameterizedSkip Undefinedeval_function_with_depsget_method_ownerregister_reference_transform resolve_ref resolve_valuetransform_reference)BooleanEvent) _to_async_geniscoroutinefunction full_groupbyc"eZdZdZedZy)Wrapperz5Helper class to allow updating literal values easily.F allow_refsN__name__ __module__ __qualname____doc__robject.lib/python3.12/site-packages/param/reactive.pyr r hs? % (Fr*r c"eZdZdZedZy) GenWrapperz9Helper class to allow streaming from generator functions.Tr!Nr#r)r*r+r-r-nsC $ 'Fr*r-c2eZdZdZeZdfd ZxZS)Triggerz?Helper class to allow triggering an event under some condition.c @t|di|||_||_yNr))super__init__internal parameters)selfr5r4params __class__s r+r3zTrigger.__init__ys! "6"  $r*NF)r$r%r&r'rvaluer3 __classcell__r8s@r+r/r/tsI GE%%r*r/ceZdZdZedZedZeZfdZ dZ e ddd d Z d Z xZS) Resolverz9Helper class to allow (recursively) resolving references.Tr!F)defaultc 2g|_t|di|yr1) _watchersr2r3)r6r7r8s r+r3zResolver.__init__s "6"r*c|jjj}t|j|}t |j|}|j ret||Dcgc] }||vs| }}|r2||z }t ||}t||Dcgc] }||vs| }}|r2|r|j |||_|Scc}wcc}wN)paramr( nested_refsrr recursive _update_refsr:)r6eventsnestedrefsr:rnew_refss r+_resolve_valuezResolver._resolve_values""..4;;/dkk62 >>#.uf#=O#=a$#=HO %eV4'25&'AS'A!Qd]A'AS!!$'  PTs' C1C C "C r()watchon_initcF|j}|j|yrC)rMrG)r6rJs r+_resolve_objectzResolver._resolve_objects""$ $r*c |jD]5}|jxs |jjj |7g|_t |dD]i\}}|jj |djjj|j|Dcgc]}|jc}kycc}w)Nc,t|jSrCidownerxs r+z'Resolver._update_refs..s bkr*r) rAinstclsrDunwatchrappendrVrNrMname)r6rJw_r7ps r+rGzResolver._update_refssA VV_quu # # + +A . %d,ABIAv NN ! !q %%++D,?,?RXAYRXQ!&&RXAYZ CAYs%C)r$r%r&r'rr(rrFr:r3rMr rQrGr;r<s@r+r>r>~sMC $ 'F&I KE#  XT40 1 r*r>c eZdZeddZy)NestedResolverT)r"rEN)r$r%r&rr(r)r*r+rcrcs $D 9Fr*rcceZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZddZdZeddZdZedZej2dZddZddZy) reactive_opsa The reactive namespace. Provides reactive versions of operations that cannot be made reactive through operator overloading, such as `.rx.and_` and `.rx.bool`. Calling this namespace (`()`) returns a reactive expression. Returns ------- Reactive expression The result of calling the reactive namespace is a reactive expression. User Guide ---------- https://param.holoviz.org/user_guide/Reactive_Expressions.html#special-methods-on-rx Examples -------- Create a Parameterized instance: >>> import param >>> class P(param.Parameterized): ... a = param.Number() >>> p = P(a=1) Get the current value: >>> a = p.param.a.rx.value Call it to get a reactive expression: >>> rx_value = p.param.a.rx() c||_yrC) _reactive)r6reactives r+r3zreactive_ops.__init__s !r*c\t|jtr |jS|SrC) isinstancergrxr6s r+_as_rxzreactive_ops._as_rxs !+DNNB!?t~~KTVKr*c\|j}tttr|St|S)zCreates a reactive expression.)rgrjrk)r6rxis r+__call__zreactive_ops.__call__s#nn R(s5bg5r*cD|jjd|S)z&Replacement for the ``and`` statement.c|xr|SrCr)objothers r+rYz#reactive_ops.and_..s   r*rm_apply_operatorr6rus r+and_zreactive_ops.and_s{{},,-MuUUr*cH|jjtS)z=__bool__ cannot be implemented so it is provided as a method.)rmrwboolrls r+r{zreactive_ops.bools{{},,T22r*cRgfd}|jj||S)z,Collects the last n items that were emitted.cj|t|kDr jdt|kDr SNr)r]lenpop)newnitemss r+collectz$reactive_ops.buffer..collects7 LL e*q. ! e*q.Lr*rv)r6rrrs @r+bufferzreactive_ops.buffers(  {{},,Wa88r*cb|jjtj|dS)z%Replacement for the ``in`` statement.Treverse)rmrwoperatorcontainsrxs r+in_zreactive_ops.in_s&{{},,X->->t,TTr*c^|jjtj|S)z%Replacement for the ``is`` statement.)rmrwris_rxs r+rzreactive_ops.is_s{{},,X\\5AAr*c^|jjtj|S)z)Replacement for the ``is not`` statement.)rmrwris_notrxs r+rzreactive_ops.is_nots{{},,X__eDDr*cH|jjtS)z<__len__ cannot be implemented so it is provided as a method.)rmrwrrls r+rzreactive_ops.lens{{},,S11r*ctjstjr tdtjrfd}nfd}|j j |g|i|S)a6 Apply a function to each item. Arguments: --------- func: function Function to apply. args: iterable, optional Positional arguments to pass to `func`. kwargs: mapping, optional A dictionary of keywords to pass to `func`. z\Cannot map a generator function. Only regular function or coroutine functions are permitted.cpKttjfd|Dd{S7w)Nc36K|]}|giywrCr)).0vargsfunckwargss r+ z2reactive_ops.map..apply..s$2XUWPQ43KD3KF3KUWs)listasynciogather)vsrrrs ``r+applyzreactive_ops.map..applys('..2XUW2X"YYZZYs &64 6cB|Dcgc]}|g|i|c}Scc}wrCr))rrrrrs r+rzreactive_ops.map..applys*:<="QQ000"===s)inspectisasyncgenfunctionisgeneratorfunction TypeErrorrrmrw)r6rrrrs ` r+mapzreactive_ops.mapsp  % %d +w/J/J4/P8   & &t , [ >,t{{},,UDTDVDDr*c\|jjtjS)zE__bool__ cannot be implemented so not has to be provided as a method.)rmrwrnot_rls r+rzreactive_ops.not_s{{},,X]];;r*cD|jjd|S)z%Replacement for the ``or`` statement.c|xs|SrCr)rss r+rYz"reactive_ops.or_..s  u r*rvrxs r+or_zreactive_ops.or_s{{},,-LeTTr*cJ|jj|g|i|S)a2 Apply chainable functions. Arguments: --------- func: function Function to apply. args: iterable, optional Positional arguments to pass to `func`. kwargs: mapping, optional A dictionary of keywords to pass to `func`. rv)r6rrrs r+pipezreactive_ops.pipe!s'-t{{},,TCDCFCCr*c|rtnt}||j|}|jjj S)aM Resolves references held by the expression. As an example if the expression returns a list of parameters this operation will return a list of the parameter values. Arguments: --------- nested: bool Whether to resolve references contained within nested objects, i.e. tuples, lists, sets and dictionaries. recursive: bool Whether to recursively resolve references, i.e. if a reference itself returns a reference we recurse into it until no more references can be resolved. )r(rF)rcr>rgrDr:rk)r6rIrF resolver_typeresolvers r+resolvezreactive_ops.resolve1s6$+1h  )L~~##&&((r*ctd|jfdd|jfddjjj S)zGReturns a new expression that is True while the expression is updating.Fr(c<jjdS)NTrrDupdateewrappers r+rYz'reactive_ops.updating..Jsgmm22$2?r*i precedencec<jjdS)NFrrrs r+rYz'reactive_ops.updating..Ksgmm22%2@r*i)r _watchrDr(rk)r6rs @r+updatingzreactive_ops.updatingGsH' ?D Q @S Q}}##&&((r*)initialc|Dcgc]}t|D]}|}}}td|Dgdfd }t|g|jScc}}w)af Returns a reactive expression that emits the contents of this expression only when the dependencies change. If initial value is provided and the dependencies are all param.Event types the expression will not be evaluated until the first event is triggered. Arguments: --------- dependencies: param.Parameter | rx A dependency that will trigger an update in the output. initial: object Object that will stand in for the actual value until the first time a param.Event in the dependencies is triggered. c3<K|]}t|tywrC)rjr)rdeps r+rz$reactive_ops.when..`s>#z#u-s) evaluatedcZrtur|s|jdSjSNT)rr]r:)rr`ris_eventr6s r+evalzreactive_ops.when..evalas,G94Y  &zz!r*)rallbindrk)r6r dependenciesdradepsrrs`` @r+whenzreactive_ops.whenNsc"(@>>! " "D 4 ##%%AsAc t}t}tjtrjj}ntj}t | |r fd}t |g|ddi|r fd}t |g|ddifd}t |j jjS)aY Returns either x or y depending on the current state of the expression, i.e. replaces a ternary if statement. Arguments: --------- x: object The value to return if the expression evaluates to True. y: object The value to return if the expression evaluates to False. )r5cVjrjjdyyNr:r:rDtriggerrr6rs r+ trigger_xz%reactive_ops.where..trigger_xs!::MM))'2r*rNTcVjsjjdyyrrrs r+ trigger_yz%reactive_ops.where..trigger_ys!zzMM))'2"r*c4|r tStSrC)r) conditionr`rXys r+ternaryz#reactive_ops.where..ternarys'0=# FmA6F Fr*) rrjrgrk_paramsr/rrDr:) r6rXrxrefsyrefsr7rrrrs ``` @r+wherezreactive_ops.wherejsAA dnnb )^^++F 0FV,  3  /U /$ /  3  /U /$ / GGT^^W]]-@-@AAr*c&t|jtr|jjSt|jtr4t |jj |jjS|jS)zj Returns the current state of the reactive expression by evaluating the pipeline. )rjrgrk_resolvergetattrrVr^rls r+r:zreactive_ops.valuesa dnnb )>>**, ,  24>>//1D1DE E>># #r*c|t|jtr tdt|jts td|jj |jur td|jj tdt||jj _y)z5Allows overriding the original input to the pipeline.zO`Parameter.rx.value = value` is not supported. Cannot override parameter value.zX`bind(...).rx.value = value` is not supported. Cannot override the output of a function.zThe value of a derived expression cannot be set. Ensure you set the value on the root node wrapping a concrete value, e.g.: a = rx(1) b = a + 1 a.rx.value = 2 is valid but you may not set `b.rx.value = 2`.NzSetting the value of a reactive expression is only supported if it wraps a concrete value. A reactive expression wrapping a Parameter or another dynamic reference cannot be updated.) rjrgrAttributeErrorrk_root_wrapperrr()r6rs r+r:zreactive_ops.values dnni 0 # DNNB/ , ^^ ! ! 7 A  >> " " * /  *7s);&r*NcN|dkr td|j||||y)z Adds a callable that observes the output of the pipeline. If no callable is provided this simply causes the expression to be eagerly evaluated. rzyUser-defined watch callbacks must declare a positive precedence. Negative precedences are reserved for internal Watchers.) onlychangedqueuedrN) ValueErrorr)r6fnrrrs r+rNzreactive_ops.watchs6 >CD D BK: Vr*c@fd}t||jdy)Ncdddlm}tr|t|y |yyNr )async_executor) parameterizedrrr)r:rrs r+cbzreactive_ops._watch..cbs. 5"2&wr5125  r*TrN)rrg)r6rrrrrs ` r+rzreactive_ops._watchs  Rt,r*)TF)NTFr)r$r%r&r'r3rmrpryr{rrrrrrrrrrrrrrpropertyr:setterrNrr)r*r+reres D"L6 V39UBE2E6<UD ),)+4&8!BJ $ $ \\<<8 W-r*reFrc tdDjDcic]\}}|t|c}}ci}t}t|ts t |dr||d<t D]\}} t | dr\t | jdD]\} }||d|d| <| jdjD]\} } | |d|d| <nt| ts| |d|<jD]\} } t | dr\t | jdD]\} }||d | d| <| jdjD]\}} | |d | d |<nt| ts| || <dfd fd tjr-fd }tdi|d|i|}|j|_n~tjr-fd}tdi|d|i|}|j|_n.s 7$3!#&$s_dinfo__fnr__arg_argkw_arg___kwarg_r`c g} D][}t|dr t|}n0t|tr t |j |j }|j|]|t|z }i} jD]R\}}t|dr t|}n0t|tr t |j |j }|||<T|jD]\}}|rU|jdr$|dd}|jr.||t|<n|jdr|dd}||vr|||<]|jds"|jds|jdr|||<||fS)Nrr__kwargr) hasattrrrjrrrVr^r]rr startswithisdigitint) wargswkwargs asynchronous combined_argsrcombined_kwargsrindex substringrrs r+combine_argumentszbind..combine_arguments sg CsH%-c2C+cii2   %  e$ ||~GBsH%-c2C+cii2"%OB  & }}GB==)qrFE}}47 c%j1]]9- "12I O358 2w'2==+Cr}}U[G\"%OB 'o--r*ctr}|St}t|tr"t |j |j }|St|}|SrC)callablerrjrrrVr^r)rrafunctions r+eval_fnzbind..eval_fn+sY H B $H-A!Y'QWWaff- -Q/ r*c?ZK||d\}}|i|}|D]}|ywNT)rr)rrrrevaledvalr rs r+wrappedzbind..wrapped7sA->wT. *M?WY AAF s(+rNclK||d\}}|i|}|23d{}|7 6ywrr)rs r+rzbind..wrappedAsI->wT. *M?WY AAF# c  Vs4202424cZK||d\}}|i|}|d{S7wrr))rrrrrr rs r+rzbind..wrappedKs<->wT. *M?WY AAF< .wrappedSs(->ug-N *M?79m?? ?r*)Fr))tuplerrrjrr enumeraterrrr rr__bound_function__rerkraddrsetattr)rrNrrkeyrrfn_depirajrkwargrpkwr wrapper_fnr^accessorr rs` `` @@r+rrs>  7$ 777=||~F~83!#& &~FD&L! *F&)$(A% V$1 1h #AHH^$<=336 uQCtA3/0>XXd^113 E5: uQCuRD124 9 %()L5 % A 1h #AHH^$<=37: xt4s34>hhtn224 U6; xt1SE235 9 % L  .B ""8, :W9|959'B #**  # #H - :W9|959'B #** X &  -< -u -  .   -< -u - @ . @"*Gg&GJw',224hx015 N[ GsKceZdZUdZiZded<dZded<iZded<iZd ed <e dW dXd Z e d Z e d Z dWfd Z dYdZedZdZedZej$dZedZdZd[dZd[dZd\d]dZdZdZdZdZdZdZedZd^d Zfd!Z d"Z!fd#Z"d$Z#d%Z$dd&d'Z%d(Z&d)Z'dWd*Z(d+Z)d,Z*d-Z+d.Z,d/Z-d0Z.d1Z/d2Z0d3Z1d4Z2d5Z3d6Z4d7Z5d8Z6d9Z7d:Z8d;Z9d<Z:d=Z;d>ZdAZ?dBZ@dCZAdDZBdEZCdFZDdGZEdHZFdIZGdJZHdKZIdLZJdMZKdNZLdOZMdPZNdQZOdRZPdSZQdTZRdUZSdVZTxZUS)_rka; `rx` allows wrapping objects and then operating on them interactively while recording any operations applied to them. By recording all arguments or operands in the operations the recorded pipeline can be replayed if an operand represents a dynamic value. Parameters ---------- obj: any A supported data structure object Examples -------- Instantiate it from an object: >>> ifloat = rx(3.14) >>> ifloat * 2 6.28 Then update the original value and see the new result: >>> ifloat.value = 1 2 zdict[str, Callable[[rx], Any]] _accessorsr)z tuple[str]_display_optionsz&dict[type, tuple[Any, dict[str, Any]]]_display_handlerszdict[str, Callable]_method_handlersc&||f|j|<y)a Registers an accessor that extends rx with custom behavior. Arguments: --------- name: str The name of the accessor will be attribute-accessible under. accessor: Callable[[rx], any] A callable that will return the accessor namespace object given the rx object it is registered on. predicate: Callable[[Any], bool] | None N)r')r[r^r% predicates r+register_accessorzrx.register_accessors$!))4tr*c &||f|j|<y)a% Registers a display handler for a specific type of object, making it possible to define custom display options for specific objects. Arguments: --------- obj_type: type | callable The type to register a custom display handler on. handler: Viewable | callable A Viewable or callable that is given the object to be displayed and the custom keyword arguments. kwargs: dict[str, Any] Additional display options to register for this type. N)r))r[obj_typehandlerrs r+register_display_handlerzrx.register_display_handlers$,3F*;h'r*c"||j|<y)zk Registers a handler that is called when a specific method on an object is called. N)r*)r[methodr0s r+register_method_handlerzrx.register_method_handlers (/V$r*c d}t|}|jdr$|jd}|jdd}ntj|s t |r4t |}td|jj}t}nt|ttfrt|dr|}d}nkt|tr.td|}t!|j"|j$}n-t'|}td|jj}t(t*|[|}||_|jd|dn|g|_||_|S) Nrrrc|SrCr)rts r+rYzrx.__new__..#r*rc|SrCr)r7s r+rYzrx.__new__..r8r*c|SrCr)r7s r+rYzrx.__new__..r8r* _shared_obj)rgetrrrrr-rrDr(rrjrrrrrrVr^r r2rk__new___fnr;r)r[rtrrrrZr8s r+r=z rx.__new__s$!#& ::d D!BjjT2G  ( ( -1DS1I ,Gow}}';';Dcgc]\}t#|j@t.r>|j@jBs(tEfd|j@jFDr|^c}_$jK|| _&tO_(d_tSjD]\}}tU||t$jVjD]0\}\}}||jXstU||2ycc}wcc}w)NFrT)r4c3:K|]}|jvywrC)_internal_params)rrar6s r+rzrx.__init__..sO'B]B]^ghl^mBn#T2DM&DN DM'') 113 $ 4 4 6,, ,!Z5QUVU\U\UeUeOAGG+>+@ 'D'8Y Idmm$<dHTN3,AO : s /J'A!J,c|jS)aw The reactive namespace. Provides reactive versions of operations that cannot be made reactive through operator overloading, such as `.rx.and_` and `.rx.bool`. Calling this namespace (`()`) returns a reactive expression. Returns ------- Reactive expression The result of calling the reactive namespace is a reactive expression. User Guide ---------- https://param.holoviz.org/user_guide/Reactive_Expressions.html#special-methods-on-rx Examples -------- Create a Parameterized instance: >>> import param >>> class P(param.Parameterized): ... a = param.Number() >>> p = P(a=1) Get the current value: >>> a = p.param.a.rx.value Call it to get a reactive expression: >>> rx_value = p.param.a.rx() )rVrls r+rkzrx.rxsFxxr*c|jt|j|_nK|jj r5|j}t|j|jd<d|_|jdS)NrF)r;rr>_objrrIr6roots r+rbzrx._obj*se    #/9DI ZZ " "::D"9$(("CD  Q #DO""r*cL|j |g|_y||jd<yr~)r;)r6rts r+rbzrx._obj4s(    # #uD "%D  Q r*c|jr |j|js|jjr|j |j SrC)rKrHrrIrrLrls r+rWz rx._current;s=   ## # [[DJJ11 MMO~~r*cp|j|S|}|j|j}|j|SrC)rMrcs r+rOzrx._compute_rootCs: :: Kjj$::Djj$ r*c|jgSt|j}|H|jj|jjDcgc]}|j }}|St |jdi}t|jdg}t|jdij}||zScc}w)Nrrr) r>rrDmethod_dependenciesr$pobjrrr<rC)r6rVrrdinforrs r+rPzrx._compute_fn_paramsKs 88 I *  $)KK$C$CDHHDUDU$V$VS$V K(B/EIInb12eiib)0023f}sCct|j}|jr/|j|jjj |j }|6|jD]}||vs|j||j }|6|j|St|jdD]}||vs|j|t|jdt|jdjzD]*}t|dD]}||vs|j|,|S)NrrrT)rF) rrQrNr]rDr:rMrrFrrC)r6psrZrarefrs r+rRzrx._compute_params[s $// " == IIdmm))// 0zz\\B;IIaL"::D  ?? "Itt45C"} #6/0dooh6O6V6V6X1YYC"3$7b=IIcN8Z  r*c|jt|jdD]o\}}|Dcgc]'}||jjvs|j)}}|s;|dj j j|j|dqt|jdD]R\}}|dj j j|j|Dcgc]}|jc}dTycc}wcc}w)a Since the parameters of the pipeline can change at any time we have to invalidate the internal state of the pipeline. To handle both invalidations of the inputs of the pipeline and the pipeline itself we set up watchers on both. 1. The first invalidation we have to set up is to re-evaluate the function that feeds the pipeline. Only the root node of a pipeline has to perform this invalidation because all leaf nodes inherit the same shared_obj. This avoids evaluating the same function for every branch of the pipeline. 2. The second invalidation is for the pipeline itself, i.e. if any parameter changes we have to notify the pipeline that it has to re-evaluate the pipeline. This is done by marking the pipeline as `_dirty`. The next time the `_current` value is requested the value is resolved by re-executing the pipeline. Nc,t|jSrCrTrWs r+rYz)rx._setup_invalidations..s R[r*rrc,t|jSrCrTrWs r+rYz)rx._setup_invalidations..s r!''{r*) r>rrQrr^rVrDr_invalidate_objrA_invalidate_current)r6rYr`r7rafpss r+rTzrx._setup_invalidationsvs& 88 )$//;PQ 6'-Lv!djj6K6K1KqvvvL1IOO))001E1EsWY0ZR&d&;&;=RSIAv 1IOO ! ! ( ()A)ATZC[TZqAFFTZC[hj ( kTMD\sD D$D cLtfd|Dryd_d_y)Nc3NK|]}|jjuywrC)rtrN)reventr6s r+rz)rx._invalidate_current..s>veuyyDMM)vs"%T)rrHrKr6rHs` r+rtzrx._invalidate_currents# >v> >   r*c4d|j_d|_yr)rrIrKrys r+rszrx._invalidate_objs $  r*cKtjx|_}tj|rH|23d{}|j|ury||_|j jjdF|d{}|j|ur-||_|j jjdyy76y7Dwr) r current_taskrJr isasyncgenrLrNrDr)r6rttaskrr:s r+_resolve_asynczrx._resolve_asyncs$+$8$8$::T   c "  5c%%T1!$ ##++G4IE!!T)!& ##++G4* 5S s33CCCCACCACCCcddlm}tj|r t |}|t |j |yr)rrr isgeneratorrrr)r6rtrs r+ _lazy_resolvezrx._lazy_resolves21   s #$Cwt22C89r*c|jr |j|js|jjr |j |j n|jj }|tus|turt|_ t|j}|rv|j||}tj|s*tj|stj|r|j!|t}|turt|x|_ }n |j}d|_|j$rt'||j$|}t)|dr/|j*j,|j*j._|S#t$rd|_|jcYSt"$r}||_|d}~wwxYw)NFrp)rKrHrrIrMrbrrrrLrF_eval_operationrr} iscoroutinerr ExceptionrErrrpr'__func__)r6rtrXrcurrents r+rz rx._resolvesj   ## # [[DJJ11 #'::#5dii4::;N;N;P$;#"2%.DNJ OO ..sI>C))#.'2E2Ec2JgNaNabeNf**3/"d{" (+ *DNWnnG <<gt||W=G 7J '-1]]-B-BDMM " " * &# ~~% $%! sCFG.G6 F??Gcdd}|jjD]s\}\}}|jjDcic] \}}||vs ||}}}|j|j ||fi|}|sc||fi|} | |usq| cS|Scc}}w#t $r ||}Y1wxYw)z4Applies custom display handlers before their output.F)r)rrDrrUr) r6rtappliesr,r0r\r]rr[rs r+_transform_outputzrx._transform_outputs*.*@*@*F*F*H &I!%!3!3!9!9!;!;AqDy1!;     - )#C8<8c2\2c>J+I   )#C. )s BB4 BB/.B/cFj}fd}|r t|g|S|S)Ncj}jrt|j}j|SrC)rWrErr)rroutr6s r+evaluatezrx._callback..evaluates4--C||c4<<0))#. .r*)rr)r6r7rs` r+ _callbackz rx._callbacks+ / *6* *r*Fc |xs |j}|jdz}|r9t|jf|j|j |j d|}n!tdd|it|jfi|}t|jfi|}t||jf|||j|j|jd|S)Nr )rWr3rZrZ)rXrYrr;rr)) rFrGdictrUrWrErMrDtyperbr>r;r)r6rXcopyrrYs r+_clonez rx._clones0  a  '+}}T\\ZZ#)F DtDtDLL'CF'CDFd((3F3tDz II !*%DHH((4==   r*c |j}|jrt||j}t|Dchc]}|j dr|}} t t t|!|zScc}w#t$rBt t tt|t |jz|zcYSwxYw)Nr`) rWrErdirrsortedsetr2__dir__rr__dict__)r6rattrextrasr8s r+rz rx.__dir__s-- <<gt||4G#&w<L<4ts7K$<L N#ego/069: :M N#c$t*o.T]]1CCfLM M NsA>A>"BAC Cc|js|jdSt|jfidd}d|_|j|S)NTrFrrrr)rErr)r6rXs r+_resolve_accessorzrx._resolve_accessor sM||;;D;) ) \\O   {{9%%r*c4t |d}|jdr|dk(s|jdrt ||S|d}|d}|r|j |d}|d}|r t ||}t |Dcgc]}|jdr|}}||vs|turE|t |!vr5|j}||_ t ||j|_ |St ||Scc}w#t$rY|SwxYw)NrrBrkr`rLrHrE) r2__getattribute__r<rrrrrrrrEr'r) r6r^ self_dictrdirtyr3rrrr8s r+rzrx.__getattribute__s)G,Z8 }}W%9M7+D1 1K((#  MMO ,G9% gv.G!\C\c1B!\C FNg2EGODU8U((*CCK %gt4<< Jw'--D J sDDD DDcl|jd}|jxsd}|dk(r7|jdk(r(t|jds|j |i|S|t jvrt j|}||}d|_t|}|||dd}|j|S)NTrrprFr) rrErGrrW set_displayrkr*r)r6rrrr3r0rXs r+rpz rx.__call__7skktk$*  Z DKK1$4WT]]T^=_#4##T4V4 4 R(( ())&1GT]F f  zz)$$r*cl|j}t|||dd|dd}|j|S)Nr Fr)rrr)r6ufuncr3rrrrXs r+__array_ufunc__zrx.__array_ufunc__NsA$$&%(H  zz)$$r*rcR|j}||||d}|j|S)Nr)rr)r6rrrrrrXs r+rwzrx._apply_operatorXs4$$&  zz)$$r*c,|jtSrC)rwabsrls r+__abs__z rx.__abs__d##C((r*c,|jtSrC)rwstrrls r+__str__z rx.__str__grr*c>|dn|f}|jtg|Sr1)rwround)r6ndigitsrs r+ __round__z rx.__round__js'_r7*#t##E1D11r*c@|jtjSrC)rwmathceilrls r+__ceil__z rx.__ceil__os##DII..r*c@|jtjSrC)rwrfloorrls r+ __floor__z rx.__floor__q##DJJ//r*c@|jtjSrC)rwrinvrls r+ __invert__z rx.__invert__s##HLL11r*c@|jtjSrC)rwrnegrls r+__neg__z rx.__neg__urr*c@|jtjSrC)rwrposrls r+__pos__z rx.__pos__wrr*c@|jtjSrC)rwrtruncrls r+ __trunc__z rx.__trunc__yrr*cB|jtj|SrCrwrrrxs r+__add__z rx.__add__}##HLL%88r*cB|jtj|SrCrwrryrxs r+__and__z rx.__and__s##HMM599r*cB|jtj|SrC)rwrrrxs r+ __contains_zrx.__contains_##H$5$5u==r*c.|jt|SrCrwdivmodrxs r+ __divmod__z rx.__divmod__s##FE22r*cB|jtj|SrC)rwreqrxs r+__eq__z rx.__eq__##HKK77r*cB|jtj|SrCrwrfloordivrxs r+ __floordiv__zrx.__floordiv__rr*cB|jtj|SrC)rwrgerxs r+__ge__z rx.__ge__rr*cB|jtj|SrC)rwrgtrxs r+__gt__z rx.__gt__rr*cB|jtj|SrC)rwrlerxs r+__le__z rx.__le__rr*cB|jtj|SrC)rwrltrxs r+__lt__z rx.__lt__rr*cB|jtj|SrC)rwrlshiftrxs r+ __lshift__z rx.__lshift__##HOOU;;r*cB|jtj|SrC)rwrmatmulrxs r+ __matmul__z rx.__matmul__rr*cB|jtj|SrCrwrmodrxs r+__mod__z rx.__mod__rr*cB|jtj|SrCrwrmulrxs r+__mul__z rx.__mul__rr*cB|jtj|SrC)rwrnerxs r+__ne__z rx.__ne__rr*cB|jtj|SrCrwrrrxs r+__or__z rx.__or__rr*cB|jtj|SrC)rwrrshiftrxs r+ __rshift__z rx.__rshift__rr*cB|jtj|SrCrwrpowrxs r+__pow__z rx.__pow__rr*cB|jtj|SrCrwrsubrxs r+__sub__z rx.__sub__rr*cB|jtj|SrCrwrtruedivrxs r+ __truediv__zrx.__truediv__##H$4$4e<R/RC S<=MQ2644l""H## [[&&  6l6! ! 5: D$   "N& .:%.%8=%))2 /022209:>38>8888<<9989<99=9GHGAL=GGGG=GKG= r*rkcZttsStfdgjS)Nc0jjSrC)rkr:)r`rts r+rYz_rx_transform..s 366<rcrerrkrIr)r*r+rQsPb# .***?'DD)m) (( %m%(}(V:X: ^-^-B !&M`N N b7 ]+r*