e!bddlZddlZddlZddlZddlmZddlmZddlm Z GddZ Gd d Z Gd d Z Gd dZ e Zy)N) functions) Parameter)ActionGroupParameterceZdZdZy) PARAM_UNSETz9Sentinel value for detecting parameters with unset valuesN)__name__ __module__ __qualname____doc__E/usr/lib/python3/dist-packages/pyqtgraph/parametertree/interactive.pyr r sCrr ceZdZdZ dZ dZy) RunOptionsactionchangedchangingN)r r r ON_ACTION ON_CHANGED ON_CHANGINGrrrrrs$IJKrrceZdZUdZeed<eed<ddfd ZdZdZd Z d Z dd Z dd Z d Z dZdZdZdZdZdZxZS)InteractiveFunctionaZ ``interact`` can be used with regular functions. However, when they are connected to changed or changing signals, there is no way to access these connections later to i.e. disconnect them temporarily. This utility class wraps a normal function but can provide an external scope for accessing the hooked up parameter signals. r r N)closuresc t|i|_||_||_|i}||_d|_d|_i|_tj||dy)a Wraps a callable function in a way that forwards Parameter arguments as keywords Parameters ---------- function: callable Function to wrap closures: dict[str, callable] Arguments that shouldn't be constant, but can't be represented as a parameter. See the rst docs for more information. extra: dict extra keyword arguments to pass to ``function`` when this wrapper is called NFr)updated) super__init__ parametersextrafunctionr _disconnectedparametersNeedRunKwargsparameterCache functoolsupdate_wrapper)selfr"rr! __class__s rrzInteractiveFunction.__init__.sc     H  "',$    x||j|j<y)z This function is connected to ``sigChanged`` of every parameter associated with it. This way, those parameters don't have to be queried for their value every time InteractiveFunction is __call__'ed N)r%name)r(paramvalues rupdateCachedParameterValuesz/InteractiveFunction.updateCachedParameterValues[s -2EJJL)rc |j} t|j|jD]#}|j|j ||% |s|j  t|t|j zD]}|||j |<y#|s|j wwxYw)z` Updates attached params from __call__ without causing additional function runs N) disconnectset intersectionr setValue reconnectr!)r(r/wasDisconnectedkwargextraKeys rr+z2InteractiveFunction._updateParametersFromRunKwargscs //+ !V11$//B ?&//u > ?# F c$**o5 4H#)(#3DJJx  4# #s A B))B>c|jj|j|j|jfD]"}t j||j $yN)sigValueChangedr:r8sigValueChangingfnrunFromChangedOrChanging)r(r6signals r_disconnectParameterz(InteractiveFunction._disconnectParameterssR (()I)IJ--u/D/DE AF MM&$"?"? @ Arc4|r|j|D]}||j|j<|jj |j |j r|jnd|j|j<y)a Binds a new set of parameters to this function. If ``clearOld`` is *True* ( default), previously bound parameters are disconnected. Parameters ---------- params: Sequence[Parameter] New parameters to listen for updates and optionally propagate keywords passed to :meth:`__call__` clearOld: bool If ``True``, previously hooked up parameters will be removed first N) removeParametersr r5rDconnectr8hasValuer7r%)r(paramsclearOldr6s rhookupParametersz$InteractiveFunction.hookupParametersxsz   ! ! # \E,1DOOEJJL )  ! ! ) )$*J*J KAFAQ W[D   -  \rc|jjD]}|j||jj|r|jjyy)z Disconnects from all signals of parameters in ``self.parameters``. Also, optionally clears the old cache of param values N)r valuesrIclearr%)r( clearCacheps rrKz$InteractiveFunction.removeParameterssZ '') )A  % %a ( )      % % ' rc|jry|j}d|_ |di|j|i}||_|S#||_wxYw)NFr)r#r$r5)r(r6r7 oldPropagaterets rrGz,InteractiveFunction.runFromChangedOrChangingsY   33 ',$ 8/%**,./C+7D ( ,8D (s A A c ,|jry|di|S)Nrr#r(r/s r runFromActionz!InteractiveFunction.runFromActions   ~f~rc,|j}d|_|S)zd Simulates disconnecting the runnable by turning ``runFrom*`` functions into no-ops TrZr( oldDisconnects rr:zInteractiveFunction.disconnects** !rc,|j}||_|S)z Sets the disconnected state of the runnable, see :meth:`disconnect` and :meth:`reconnect` for more information rZ)r( disconnectedr_s rsetDisconnectedz#InteractiveFunction.setDisconnecteds ** )rc,|j}d|_|S)zISimulates reconnecting the runnable by re-enabling ``runFrom*`` functionsFrZr^s rr>zInteractiveFunction.reconnects** "rc t|jd|jjdtt |S)Nz(``) at )typer r"hexidr(s r__str__zInteractiveFunction.__str__s8t*%%&c$--*@*@)ARPTXXXrc t|dt|jdt|jdt|jzS)Nz with keys: parameters=z, extra=z , closures=)strlistr r!rrhs r__repr__zInteractiveFunction.__repr__sT It/01$**%&'T]]+,. . r)NT)T)r r r r rk__annotations__rr3r8r+rIrPrKrGr\r:rbr>rirm __classcell__)r)s@rrr"saM-1=:* 24 A \* (   Y rrceZdZejZdZdZdZdZ e ddZ gdZ dZ dZej d Zdeeeeeed d Zej*ed Zd ZddZdZedZdZdZddZdZdZ dZ!dZ"dZ#y) InteractorNTrRun)re defaultName) runOptionsparent titleFormatnestexistOkrunActionTemplatec (|jdi|y)z Initializes an Interactor with initial keyword arguments which can be anything accepted by :meth:`setOpts` NrsetOptsr[s rrzInteractor.__init__s  vrc |j}t|}t|j|}|rtd|d|i}i}|j D]\}}||||<|||<|j j ||S)a[ Overrides the default options for this interactor. Note! This method should only be used if you spawn your own Interactor; do not call it on ``defaultInteractor``. Instead, use ``defaultInteractor.optsContext``, which is guaranteed to revert to the default options when the context expires. Parameters ---------- opts Keyword arguments to override the default options Returns ------- dict of previous options that were overridden. This is useful for resetting the options afterward. zUnrecognized options: z. Must be one of: )getOptsr; differenceKeyErrorr.__dict__r-) r(optsoldOptsallowederrorstoReturntoUser1r2s rr|zInteractor.setOptss$,,.g,T%%g. 3F8;MgYWX Xjjl FB"2;HRLE"I  U#rc+\K|jdi|}d|jdi|yw)z Creates a new context for ``opts``, where each is reset to the old value when the context expires Parameters ---------- opts: Options to set, must be one of the keys in :attr:`_optNames` Nrr{)r(rrs r optsContextzInteractor.optsContexts/$,,&&  ws*,)ignoresrtrurvrwryrxc @|turi|j|}t} |jD cic]} | | tus| | | } } |jdi| } ~~~~~~|j |}|j |jfi| }|jdg}|Dcgc]}|d }}|j||}|g}t|t|jz}t|t|z}|D]@}||j|d}||jvs)|tus2||j|<B|Dcgc]4}|dtur'|d|jvr|d|jvr|d6}}|r$|jdi| td|d|dg}|Dcgc] }||vs| }}|D]=}||j|}|j!|||}|-|j#|?|j%|t&j(|j*vr5|j-|||j/d}|r|j#||j0r|n|}|jdi| |Scc} wcc}wcc}wcc}w) a Interacts with a function by making Parameters for each argument. There are several potential use cases and argument handling possibilities depending on which values are passed to this function, so a more detailed explanation of several use cases is provided in the "Interactive Parameters" doc. if any non-defaults exist, a value must be provided for them in ``overrides``. If this value should *not* be made into a parameter, include its name in ``ignores``. Parameters ---------- function: Callable function with which to interact. Can also be a :class:`InteractiveFunction`, if a reference to the bound signals is required. runOptions: ``GroupParameter.`` value How the function should be run, i.e. when pressing an action, on sigValueChanged, and/or on sigValueChanging ignores: Sequence Names of function arguments which shouldn't have parameters created parent: GroupParameter Parent in which to add argument Parameters. If *None*, a new group parameter is created. titleFormat: str or Callable title of the group sub-parameter if one must be created (see ``nest`` behavior). If a function is supplied, it must be of the form (str) -> str and will be passed the function name as an input nest: bool If *True*, the interacted function is given its own GroupParameter, and arguments to that function are 'nested' inside as its children. If *False*, function arguments are directly added to this parameter instead of being placed inside a child GroupParameter runActionTemplate: dict Template for the action parameter which runs the function, used if ``runOptions`` is set to ``GroupParameter.RUN_ACTION``. Note that if keys like "name" or "type" are not included, they are inferred from the previous / default ``runActionTemplate``. This allows items that should only be set per-function to exist here, like a ``shortcut`` or ``icon``. existOk: bool Whether it is OK for existing parameter names to bind to this function. See behavior during 'Parameter.insertChild' overrides: Override descriptions to provide additional parameter options for each argument. Moreover, extra parameters can be defined here if the original function uses ``**`` to consume additional keyword arguments. Each override can be a value (e.g. 5) or a dict specification of a parameter (e.g. dict(type='list', limits=[0, 10, 20])) childrenr5r7zCannot interact with `z#` since it has required parameters z, with no default or closure values provided.tipr)r rylocals _optionNamesr|_toInteractiveFunctionfunctionToParameterDictr"pop_resolveFunctionGrouprlrr;indexr! ValueErrorresolveAndHookupParameterChildappendrPrrrt_resolveRunActiongetrw)r(r"rrtrurvrwryrx overrideslocsr1rrfuncDictrchchNames funcGroup recycleNamesr5r7missingChildren useParamsn checkNames childOptschildrretValues rinteractzInteractor.interacts~ K / O4#9#9 O=N O x'+'8'8XDHK>)e;.F',t$ - '{k)6 ("3"336 (..0 vJ    DLL #7 #( 2U"##OQ   !(=AAW,s#J J ( J 9J4 J>Jc (|j|fi|SrC)r)r(r"r/s rr3zInteractor.__call__st}}X000rc fd}|S)z Calls :meth:`interact` and returns the :class:`InteractiveFunction`. Parameters ---------- kwargs Keyword arguments to pass to :meth:`interact` cdt|ts t|}j|fi|SrC) isinstancerr)r"r/r(s r decoratorz&Interactor.decorate..decorators0h(;<.x8 DMM( -f -Orr)r(r/rs`` rdecoratezInteractor.decorates  rcb|j}t|t}||r|s|S|r|S||S)aO Converts a function name to a title based on ``self.titleFormat``. Parameters ---------- name: str Name of the function forwardStringTitle: bool If ``self.titleFormat`` is a string and ``forwardStrTitle`` is True, ``self.titleFormat`` will be used as the title. Otherwise, if ``self.titleFormat`` is *None*, the name will be returned unchanged. Finally, if ``self.titleFormat`` is a callable, it will be called with the name as an input and the output will be returned )rvrrk)r(r5forwardStringTitlervisStrings r _nameToTitlezInteractor._nameToTitles?&& k3/  84FK  4  rc|j}|jrmtjdi|}|jr'|jj ||j }|j j|j|S)z Returns parent parameter that holds function children. May be ``None`` if no top parent is provided and nesting is disabled. rxr) rurwrcreateaddChildrx sigActivatedrLr\)r( functionDictinteractiveFunctionrs rrz Interactor._resolveFunctionGroupsl KK 99!((8<8I{{ KK00DLL0Q  " " * *+>+L+L Mrct|tr|St|}tj|s|n |j}t |dr|j j||S|g|_|S)NinteractiveRefs)rrinspectismethod__func__hasattrrr)r" interactiverefOwners rrz!Interactor._toInteractiveFunctionsq h 3 4O *(3 #*#3#3H#=88CTCT 8. /  $ $ + +K 8)4}H $rct|stjdi|}n|j||j}tj |j vr%|jj|jtj|j vr%|jj|j|S)Nrr) rrrrxrrrtrDrLrGrrE)r( functionGrouprrrs rrz)Interactor.resolveAndHookupParameterChilds$$1y1E!**9dll*KE  DOO 3  ! ! ) )*=*V*V W  ! !T__ 4  " " * *+>+W+W X rc<t|tr|jdd}|S|j|j|}t j di|}|jj|j|r|j||j|S)NT)visiblerr) rr setButtonOpts_makePopulatedActionTemplater rrrrLr\rrx)r(rr functionTipr createOptss rrzInteractor._resolveRunActions m%9 :  ' ' ' 5E ::#,,kJ$$2z2E    & &':'H'H I&&udll&C rc|jj}|jdd}|jr|n|}|j d||r|j d||S)Nrsrrr5r)ryr,rrw setdefault)r( functionNamerrrsr5s rrz'Interactor._makePopulatedActionTemplates\++002  nn]E: "ii{\fd+   ! !% 5rc g}|j}td i|j|ddi}t|d||}|j|j |d|d<t j |j}|jrKtj|j\}} |r'|jd||d jd|t|} |jD cgc]} | j} } t jj } t jj"}|| vr(| d =|Dcgc] }|| vs| }}| j%|| | vr| | j'| =| D]G}|j)|}|j+|||j)|i}|j-|I|Scc} wcc}w) zJ Converts a function into a list of child parameter dicts rF _actiongroup)r5rerbuttonT)rtitlerrr)r dictrrvrr signaturer r pydocsplitdocrrlrRkindrVAR_POSITIONAL VAR_KEYWORDextendrrcreateFunctionParameterr)r(r"rrr5btnOptsout funcParamssynopsis_rrUparameterKinds _positional_keywordrnotInSignaturer6pgDicts rrz"Interactor.functionToParameterDicts  P::4@P%P>HWU    ',,Td,KCL&&x0;;   ..)9)9:KHauh/H ((9*% *4*;*;*=>Q!&&>>''66 $$00 ~ % 2)2JAaz6IaJNJ   n - . (>// <= $DNN4(E11$y}}TSU?VWF OOF #  $  -?Ks1G  GGc|=|j|jur%|j}|t|jd}ni}|j }t |t sd|i}|j|||d<|jdt|j!|jd|j||jdt|dj|S)a~ Constructs a dict ready for insertion into a group parameter based on the provided information in the ``inspect.signature`` parameter, user-specified overrides, and true parameter name. Parameter signature information is considered the most "overridable", followed by documentation specifications. User overrides should be given the highest priority, i.e. not usurped by parameter default information. Parameters ---------- name : str Name of the parameter, comes from function signature signatureParameter : inspect.Parameter Information from the function signature, parsed by ``inspect`` overridesInfo : dict User-specified overrides for this parameter. Can be a dict of options accepted by :class:`~pyqtgraph.parametertree.Parameter` or a value )r7rer7r5rre) defaultemptyrer r,rrr-rr rvr)r(r5signatureParameter overridesInfor signatureDictrs rrz"Interactor.createFunctionParameter6s(  *"**2D2J2JJ )00G&-tG}7M7MNMM##%-.$m4M m$v ';/    '   gt'8'8'> ?&$vg"7"@"@A rc(d|jS)NzInteractor with opts: )r~rhs rrizInteractor.__str__gs' '788rct|SrC)rkrhs rrmzInteractor.__repr__js 4yrcV|jDcic]}|t||c}Scc}wrC)rgetattr)r(attrs rr~zInteractor.getOptsms(6:6G6GHdgdD))HHHs&)F)N)$r r r rrrtrurvrwrxrryrrr| contextlibcontextmanagerrr rr&wrapsr3rrr staticmethodrrrrrrrirmr~rrrrqrqs%%J FK DG(>L@    $ %BY__X11$!0   ,\/b9Irrq)rr&rrrrrFrparameterTypesrr rrrqrrrrrsU 0DD&i i X`I`IF <r