.dgdZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlmZddlmZmZmZddlmZmZmZddlmZddlmZddl mZmZdd l mZmZdd lm Z dd lm!Z!m"Z"m#Z#m$Z$m%Z%d d l&m'Z'd dl(m)Z)m*Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8e/r d dl9m:Z:m;Z<e:dZ=nd dl(mdddd?d@Zmd>dddd?dAZnddBZodCZpedDdEZqepeqdFedGdHZreperdIedJdKZsepesdLedMdNZtepetdOedPdQZuGdRdPeuZvGdSdTewZxGdUdVexZyGdWdXeyZzGdYdZezZ{Gd[d\Z|d]Z}Gd^d_Z~Gd`daZGdbdcZGdddeewZdZddfgdddgdfdhZddfgdiddjfdkZiZdlZe8dmZdnZdoZeee<eee<eee<dZddpZddqZdrZGdsdtZGdudvZGdwdxeZdyZGdzd{eZd|ZGd}d~eZGddeZeZGddZy#e>$r d dl(m??Fc,tj|S)z Appends a transform to extract potential parameter dependencies from an object. Arguments: --------- transform: Callable[Any, Any] )_reference_transformsappend) transforms r7register_reference_transformrUzs ! ' ' 22rPcjtD])}t|ts t|dr|S||}+|S)a* Applies transforms to turn objects which should be treated like a parameter reference into a valid reference that can be resolved by Param. This is useful for adding handling for depending on objects that are not simple Parameters or functions with dependency definitions. _dinfo)rR isinstance Parameterhasattr)argrTs r7transform_referencer\s;+ c9 %h)?  Jn+ JrPc Pdi}}t|dr|jd}|jjdi}|std|DrJd|D}|j Dcic]&\}}|t |j |j(}}}||i|Scc}}w)z Evaluates a function after resolving its dependencies. Calls and returns a function after resolving any dependencies stored on the _dinfo attribute and passing the resolved values as arguments. rW dependencieskwc3<K|]}t|tywN)rXrY).0ds r7 z*eval_function_with_deps..sEHq*Q 2Hc3\K|]$}t|j|j&ywrb)getattrownerrK)rcdeps r7rez*eval_function_with_deps..s EHSGCIIsxx0Hs*,)rZrWr3anyitemsrhrirK)functionargskwargsarg_depskw_depsnrjs r7eval_function_with_depsrssr&Dx"??>2//%%dB/ cEHEEEHEDDKMMOTO&!SaCHH55OFT T $V $$Us,+B"c|snt|ttfrt|d|DSt|tr&t|d|j DSt|t rFt t|jt|jt|jSt|}tj|}t|ds t|s|rt!|}|r t#|}|St|t$r t'|j(|j*}|S)z2Resolves the current value of a dynamic reference.c32K|]}t|ywrb resolve_value)rcvs r7rez resolve_value..s;U=+Usc3NK|]\}}t|t|fywrbrv)rckrxs r7rez resolve_value..s$ZMDAqM!,mA.>?Ms#%rW)rXlisttupletypedictrlslicerwstartstopstepr\inspectisgeneratorfunctionrZr$rsr!rYrhrirK)value recursiveis_gens r7rwrws  ED%= )tE{;U;;; E4 tE{ZEKKMZZZ E5 ! %++ & %** % %** %   &E  ( ( /Fuh#6u#='. !%(E L E9 % UZZ0 LrPc 8|rt|tttfr#|Dcgc]}t ||D]}|c}}St|t r:|j Dcgc]}|D]}t ||D]}|c}}}St|trD|j|j|jfDcgc]}t ||D]}|c}}St|}t|drt|di}t|jdg}t|jdij}g} ||zD]} t| t rut#|} | | j$vr| j$| } nLd| vr<| j'd} | } | ddD]} t| | } | j$| d} n t| | } | j)t | | St|t*r|gSgScc}}wcc}}}wcc}}w)z7Resolves all parameters a dynamic reference depends on.rWr_r`rAN)rXr{r|set resolve_refr~rlrrrrr\rZrhr3valuesstrget_method_ownerr?splitextendrY) referencerrxrkvodinfornrorefsr[ripathattrs r7rrs i$s!3 4(Ly!+a2KQA2KAyL L  4 ( ) 1a 1"2a{STV_G`!AG`A2A 1a a  5 ) )PtP!ZefgirZsUVAZsAPt t#I.Iy(# 8R0EIInb12eiib)00236MC#s#(3%++%++c*CCZ99S>DC $Sb %c40!*))DH-C!%-C KK C( )" Iy ){ I9MatsH %!HHc|S)z&To be removed when set_hook is removedr^)objvals r7_identity_hookrs JrPceZdZdZdZdZy) _Undefinedz_ Dummy value to signal completely undefined values rather than simple None values. ctd)NzUse `is` to compare Undefined) RuntimeErrorselfs r7__bool__z_Undefined.__bool__s:;;rPcy)Nz r^rs r7__repr__z_Undefined.__repr__srPN)__name__ __module__ __qualname____doc__rrr^rPr7rrs < rPrc#pK|j}ttttt t g}gd}||vrtd|d|t}|j}|j||j| d|j|y#|j|wxYww)z)Temporarily modify param's logging level.)rrrrrr=zLevel z not in N) upperrrrrrr= ExceptionrOgetEffectiveLevelrFindex)levellevels level_names param_logger logging_levels r7rrs KKMET7E8W =FNK K& &<==>& !$B$ ''rPcg}t|ddDcgc]}|}}|D]}t|ds||jz } |Scc}w)z] Return a list of slot names for slots defined in `class_` and its superclasses. rN __slots__)rrZr)r all_slotscparent_param_classess r7 get_all_slotsrls[I'0'8'=>'=!A'=> ! 1[ ! q{{ "I"  ?s Achtt|Dcgc]}t||r|c}Scc}w)z Return a list of slots for which values have been set. (While a slot might be defined, if a value for that slot hasn't been set, then it's an AttributeError to request the slot's value.) )rr}rZ)instanceslots r7get_occupied_slotsr|s<+4>: ':Tx% : '' 's/)rctd||fDr||k(S tdt||DS#t$r||k(cYSwxYw)a3 Return a single boolean for arg1==arg2, even for numpy arrays using element-wise comparison. Uses all(arg1==arg2) for sequences, and arg1==arg2 otherwise. If both objects have an '_infinitely_iterable' attribute, they are not be zipped together and are compared directly instead. c34K|]}t|dyw)_infinitely_iterableNrZ)rcels r7rezall_equal..s E272- .c3,K|] \}}||k(ywrbr^)rca1a2s r7rezall_equal..s:/B28/s)allr TypeError)arg1arg2s r7 all_equalrsU E$t EETz:#dD/::: Tzs7AAcfd}|S)z[ Class decorator for creating a class with a metaclass. .. deprecated:: 2.0.0 c |jj}|jdd|jdd|jddD]}|j||j|j |S)N__dict__ __weakref__rr^)rcopypopr3r __bases__)cls orig_vars slots_varr)s r7wrapperzadd_metaclass..wrappersiLL%%'  j$' mT*"{B7I MM) $8s}}i@@rPr^)r)rs` r7 add_metaclassrsA NrPceZdZdZdZdZy) bothmethodz 'optional @classmethod' A decorator that allows a method to receive either the class object (if called on the class) or the instance object (if called on the instance) as its first argument. c||_yrbmethod)rrs r7__init__zbothmethod.__init__s  rPct||jj|S|jj||Srb)r__get__)rrris r7r zbothmethod.__get__s6  ;;&&u- -;;&&x7 7rPN)rrrrrr r^rPr7rrs8rPrcLfd}t||g|jdzS)Nct||gSrb)rh)rrrns r7_getattrz_getattrr.._getattrssD(4((rPrA)r r)rrrnr s ` r7 _getattrrr s$) (SEDJJsO3 44rPc(d|j_|S)z)Disables instance parameters on the classT)rdisable_instance_paramsrs r7no_instance_paramsrs26C/ JrPctj|}||_i|_|jjD]@}t ||}t |s|dk7s!t||tj|B|S)zWReturn a Parameter object suitable for instantiation given the class's Parameter objectdefault)rrir __class__ _all_slots_rhrsetattr)paramobjrirsrxs r7_instantiate_param_objrsl (AAGAJ[[ $ $ AqM  #Y Aq$))A, '% HrPcLt|jddr|jrtt|jdds`|j}||jj vr#t |||jj |<|jj |}|S)z Given a Parameterized object and one of its class Parameter objects, return the appropriate Parameter object for this instance, instantiating it if need be. initializedFr)rhr per_instancer}rKrr)rr?keys r7_instantiated_parameterrs  --}eDI[I[ D'779RTY Zjj m33:: :8NuVc8dM ) ) 0 0 5--44S9 LrPcfd}|S)Nc|V|jjj|j}| t ||}|||ur|j ||y|||Srb)rrr3rKr__set__)rrrinstance_paramfs r7_fzinstance_descriptor.._fsi ? 0077;;DIIFN%!8d!C)d..H&&sC0sC  rPr^)r#r$s` r7instance_descriptorr%s ! IrPc~tj|syt|tr |j}|j S)z/Gets the instance that owns the supplied methodN)rismethodrXrfunc__self__rs r7rr s0   F #&'" ??rPcRtjdtdt|S)zm Decorator to make a repr function return fillvalue for a recursive call .. deprecated:: 1.12.0 zKrecursive_repr has been deprecated and will be removed in a future version.category stacklevel fillvalue)warningswarn_ParamFutureWarningr r/s r7recursive_reprr4s&  MMU$ Y //rPc \|rg}t|D]\}}t|dkDr|nd}t|tr7t|dk(r)t|dtr|j ||fz_t|tr|j |t |f|j d||fnT|rDt|jDcgc]\}\}}||t|dkDr|ndf}}}}ndt dfg}gg} }|D]\}}}t|tr(t|t r|}nAddl m } | |}n1t|tr!td|Drddl m } | |}t|t s td| j |||f|j |tt|t|k7r td td i} | j!d | it#fd } | | _| Scc}}}w) a output allows annotating a method on a Parameterized class to declare that it returns an output of a specific type. The outputs of a Parameterized class can be queried using the Parameterized.param.outputs method. By default the output will inherit the method name but a custom name can be declared by expressing the Parameter type using a keyword argument. The simplest declaration simply declares the method returns an object without any type guarantees, e.g.: @output() If a specific parameter type is specified this is a declaration that the method will return a value of that type, e.g.: @output(param.Number()) To override the default name of the output the type may be declared as a keyword argument, e.g.: @output(custom_name=param.Number()) Multiple outputs may be declared using keywords mapping from output name to the type or using tuples of the same format, i.e. these two declarations are equivalent: @output(number=param.Number(), string=param.String()) @output(('number', param.Number()), ('string', param.String())) output also accepts Python object types which will be upgraded to a ClassSelector, e.g.: @output(int) rNr+r) ClassSelectorrc3<K|]}t|tywrb)rXr})rcts r7rezoutput..`s-Q5ajD.A5rfzVoutput type must be declared with a Parameter class, instance or a Python object type.z:When declaring multiple outputs each value must be unique.rWoutputsc|i|Srbr^)rnr`r(s r7_outputzoutput.._outputpsTBrP) enumeratelenrXr|rrSrYrlr} issubclassr6r ValueErrorrrhupdaterrW) r(outputr`r9ioutrKotypenames processedr6rWr;s ` r7rBrB!sL'FAs[1_$A#u%#c(a-Js1vs[^:]*):?(?P.*)whatrArz(?P.*)(\.)(?P.*)rrNr)countstriprematchgroup)specmrJrrrs r7_parse_dependency_specrRys ::c?A   ::} t| tr|j| %t| ||\} } || z }|| z }@||fS)ac Resolves dependencies declared on a Parameterized method. Dynamic dependencies, i.e. dependencies on sub-objects which may or may not yet be available, are only resolved if dynamic=True. By default intermediate dependencies, i.e. dependencies on the path to a sub-object are returned. For example for a dependency on 'a.b.c' dependencies on 'a' and 'b' are returned as long as intermediate=True. Returns lists of concrete dependencies on available parameters and dynamic dependencies specifications which have to resolved if the referenced sub-objects are defined. rWr_) rhrr3r{rr?inst _spec_to_objrXPInforS_params_depended_on) minfodynamic intermediatedeps dynamic_depsrrdddeps ddynamic_depsrj method_depsmethod_dynamic_depss r7rWrWsR,D ELL(B /E YY~tEIIOO'< =-2ZZ-? UZZVVccdegnp|}} % C#u% C 3FsGUa3b0 0 # 33 >  rPc4g}|D]}tt||js|j|4|j|n |j}t ||j|j |j|j |j}|j||D]h}|jj|j|\}}|D]7} t| t r|j| %|t| |dz }9j|S)a  Resolves constant and dynamic parameter dependencies previously obtained using the _params_depended_on function. Existing resolved dependencies are updated with a supplied parameter instance while dynamic dependencies are resolved if possible. rTrrKpobjrJrZr) r>r}rrSrTrVrKr?rJrUrPrXrW) rresolvedrYrZr_rjrT subresolved_subdeps r7_resolve_mcs_depsrisL$s)SWW-    $ hh&sCHH377CHH-CHH>C //|/T Q!F&%(##F+ 3F VWX YY " rPc&|jdd}|jd}|y|D]}|D]}|dk(rS|jtnt|j|d}|jtnt|j|d}nl|jtn#t|jj ||d}|jtn#t|jj ||d}t j||ryy)z Checks whether a subobject event should be skipped. Returns True if all the values on the new subobject match the values on the previous subobject. rJrchangedNFT)r3r Undefinedr newr? Comparatoris_equal)rrorJrkerrrms r7 _skip_eventrqs ::fg &Djj#G Aw#$55=iiq$6O#$55=iiq$6O#$55=ii APTVZ6[#$55=ii APTVZ6[&&sC0 rPc,t|jdt|jdjz}g}|D]}t|trt |}|j d^}}|D]}t||d}|td||jvr&|j|}||vsu|j|tt||D]}||vs|j|||vs|j||S)zJExtract references from a method or function that declares the references.r_r`rANz/Cannot depend on undefined sub-parameter {p!r}.) r{rWrrXrrrrhr@r?rSextract_dependencies) rm subparametersrrrisubpssubprcsps r7rsrss89$xt?T?[?[?]:^^M F  a $X.E IUAtT2=$%VWWEKK{{1~v%MM$'.wua/@AB' b)Bf_ MM! #$ MrPrrJrkcallbackrmcbK|r||tr t|||ds|d{yy7wN)rJrkrqrJrkryrmrs r7 _async_callerr~s3& k6gNjOs $/-/c8|r||t|||ds|Syr{r|r}s r7 _sync_callerrs&& T7 ;z t[)H28: keywords) `onlychanged`: If True, only trigger for actual changes, not setting to the current value `parameter_names`: List of Parameters to watch, by name `what`: What to watch on the Parameters (either 'value' or a slot name) `queued`: Immediately invoke callbacks triggered during processing of an Event (if False), or queue them up for processing later, after this event has been handled (if True) `precedence`: A numeric value which determines the precedence of the watcher. Lower precedence values are executed with higher priority. ctt|j|}|j|d|vrd|d<t ||fi|S)z:Allows creating Watcher without explicit precedence value. precedencer)r~r_fieldsrAsuper__new__)cls_rnrorrs r7rzWatcher.__new__ssJc$,,-. f v %#$F< wt.v..rPc t|}dj|jDcgc]}|dt||c}}|jd|dScc}w)N, =())r}joinrrhr)rrr#attrss r7__str__zWatcher.__str__{s\4j  L 1aS'$"2!56 LM,,qq))MsA)rrrrrr __classcell__rs@r7rrQsB/*rPceZdZdZdZdZy)ParameterMetaclassz>Metaclass allowing control over creation of Parameter classes.c d|vr|d|d<ttd|d<i}ttd|DD]1}|j t j t|dg3d|vrg|d<n'|j t j |dt||d<tj||||S)Nr __classdocdocc3@K|]}|jdddyw)Nr)__mro__)rcbases r7rez-ParameterMetaclass.__new__..sEut TrT 2usrr) propertyr rr rAr~fromkeysrhr{r}r)mcs classnamebases classdictrbclss r7rzParameterMetaclass.__new__s  !$-i$8Il # ( 5(9: ) EuEFGD   T]]74b+IJ KH i '%'Ik "   T]]9[+AB C#' ? - ||CE9==rPcd|dk(rtj|dStj||S)Nrr)r}__getattribute__)rrKs r7rz#ParameterMetaclass.__getattribute__s1 ?((\: :((T2 2rPN)rrrrrrr^rPr7rrsH>:3rPrcLeZdZdZedZefdZedZxZS)_ParameterBasezb Base Parameter class used to dynamically update the signature of all the Parameters. cb|jj}|jd|d<|S)N_labellabel)_slot_defaultsrr)rdefaultss r7_modified_slots_defaultsz'_ParameterBase._modified_slots_defaultss.%%**,$LL2rPct| |jy#t$r't j |j |_YywxYwrb)r__init_subclass___update_signaturerr signaturer __signature__)rrs r7rz _ParameterBase.__init_subclass__sJ !# @  ! ! # @!( 1 1#,, ?C  @s"-AAc |j}i}t|jD]\}}|jj dr#t j |j}|jjD]+\}}|dk(r |dk\r(|jt jjk(r:|jt jjt jj fvr{t#|ddt$ur[||vrt'd|d|jd||}t)|rt+|dr |j,}|j/| } n|} |dk\r*| j/t jj0 } |j3|| .d } t5|j7| }j/| } | |_y)Nrgrrrz Argument z of Parameter z has no entry in _slot_defaults.sig)r)kindcT|jtjjk(ryy)Nrr)rr Signatureempty)rs r7_sorterz1_ParameterBase._update_signature.._sorters yyG--333rPr)r)rr<mror startswithrrrrrlrrrrrY VAR_KEYWORDVAR_POSITIONALrhrl LookupErrorcallablerZrreplace KEYWORD_ONLY setdefaultsortedrr) rrnew_parametersrCklsrpname parameterr new_parameterrnew_sigs r7rz _ParameterBase._update_signatures//1 *FAs||&&s+##CLL1C$'NN$8$8$: yF?6i//73D3D3J3JJ>>g&7&7&C&CWEVEVEeEe%ff9i6)CH,)'ys||>NO77'uoG(WWe-D")++$-$5$5g$5$FM$-M6$1$9$9w?P?P?]?]$9$^M))%?+%; +6    5 5 7WE+++8#rP) rrrr classmethodrrrrrs@r7rrsF   @ @'$'$rPrceZdZdZgdZdej iZedddddddddddd Z gdZ e j d"dddddddddddd d Z eefeeeeeeeeeeed d Z ed Zed Zd#dZedZedZej.dZdZdZfdZdZdZdZdZdZe dZ!dZ"dZ#dZ$dZ%dZ&d Z'd!Z(xZ)S)$rYaQ An attribute descriptor for declaring parameters. Parameters are a special kind of class attribute. Setting a Parameterized class attribute to be a Parameter instance causes that attribute of the class (and the class's instances) to be treated as a Parameter. This allows special behavior, including dynamically generated parameter values, documentation strings, constant and read-only parameters, and type or range checking at assignment time. For example, suppose someone wants to define two new kinds of objects Foo and Bar, such that Bar has a parameter delta, Foo is a subclass of Bar, and Foo has parameters alpha, sigma, and gamma (and delta inherited from Bar). She would begin her class definitions with something like this:: class Bar(Parameterized): delta = Parameter(default=0.6, doc='The difference between steps.') ... class Foo(Bar): alpha = Parameter(default=0.1, doc='The starting value.') sigma = Parameter(default=0.5, doc='The standard deviation.', constant=True) gamma = Parameter(default=1.0, doc='The ending value.') ... Class Foo would then have four parameters, with delta defaulting to 0.6. Parameters have several advantages over plain attributes: 1. Parameters can be set automatically when an instance is constructed: The default constructor for Foo (and Bar) will accept arbitrary keyword arguments, each of which can be used to specify the value of a Parameter of Foo (or any of Foo's superclasses). E.g., if a script does this:: myfoo = Foo(alpha=0.5) myfoo.alpha will return 0.5, without the Foo constructor needing special code to set alpha. If Foo implements its own constructor, keyword arguments will still be accepted if the constructor accepts a dictionary of keyword arguments (as in ``def __init__(self,**params):``), and then each class calls its superclass (as in ``super(Foo,self).__init__(**params)``) so that the Parameterized constructor will process the keywords. 2. A Parameterized class need specify only the attributes of a Parameter whose values differ from those declared in superclasses; the other values will be inherited. E.g. if Foo declares:: delta = Parameter(default=0.2) the default value of 0.2 will override the 0.6 inherited from Bar, but the doc will be inherited from Bar. 3. The Parameter descriptor class can be subclassed to provide more complex behavior, allowing special types of parameters that, for example, require their values to be numbers in certain ranges, generate their values dynamically from a random distribution, or read their values from a file or other external source. 4. The attributes associated with Parameters provide enough information for automatically generating property sheets in graphical user interfaces, allowing Parameterized instances to be edited by users. Note that Parameters can only be used when set as class attributes of Parameterized classes. Parameters used as standalone objects, or as class attributes of non-Parameterized classes, will not have the behavior described here. )rKrrr instantiaterreadonlypickle_default_value allow_Nonerrri allow_refs nested_refsrjsonNFT) rrrrrrrrrrrr)rrrKrrrrri) rrrrrrrrrrrc yrbr^ rrrrrrrrrrrrrs r7rzParameter.__init__ rPc d|_d|_| |_| |_||_||_||_|duxs|du|_||_||_ |j|||_ |j| i|_ | |_y)a Initialize a new Parameter object and store the supplied attributes: default: the owning class's value for the attribute represented by this Parameter, which can be overridden in an instance. doc: docstring explaining what this parameter represents. label: optional text label to be used when this Parameter is shown in a listing. If no label is supplied, the attribute name for this parameter in the owning Parameterized object is used. precedence: a numeric value, usually in the range 0.0 to 1.0, which allows the order of Parameters in a class to be defined in a listing or e.g. in GUI menus. A negative precedence indicates a parameter that should be hidden in such listings. instantiate: controls whether the value of this Parameter will be deepcopied when a Parameterized object is instantiated (if True), or if the single default value will be shared by all Parameterized instances (if False). For an immutable Parameter value, it is best to leave instantiate at the default of False, so that a user can choose to change the value at the Parameterized instance level (affecting only that instance) or at the Parameterized class or superclass level (affecting all existing and future instances of that class or superclass). For a mutable Parameter value, the default of False is also appropriate if you want all instances to share the same value state, e.g. if they are each simply referring to a single global object like a singleton. If instead each Parameterized should have its own independently mutable value, instantiate should be set to True, but note that there is then no simple way to change the value of this Parameter at the class or superclass level, because each instance, once created, will then have an independently instantiated value. constant: if true, the Parameter value can be changed only at the class level or in a Parameterized constructor call. The value is otherwise constant on the Parameterized instance, once it has been constructed. readonly: if true, the Parameter value cannot ordinarily be changed by setting the attribute at the class or instance levels at all. The value can still be changed in code by temporarily overriding the value of this slot and then restoring it, which is useful for reporting values that the _user_ should never change but which do change during code execution. pickle_default_value: whether the default value should be pickled. Usually, you would want the default value to be pickled, but there are rare cases where that would not be the case (e.g. for file search paths that are specific to a certain system). per_instance: whether a separate Parameter instance will be created for every Parameterized instance. True by default. If False, all instances of a Parameterized class will share the same Parameter object, including all validation attributes (bounds, etc.). See also instantiate, which is conceptually similar but affects the Parameter value rather than the Parameter object. allow_None: if True, None is accepted as a valid value for this Parameter, in addition to any other values that are allowed. If the default value is defined as None, allow_None is set to True automatically. allow_refs: if True allows automatically linking parameter references to this Parameter, i.e. the parameter value will automatically reflect the current value of the reference that is passed in. nested_refs: if True and allow_refs=True then even nested objects such as dictionaries, lists, slices, tuples and sets will be inspected for references and will be automatically resolved. default, doc, and precedence all default to None, which allows inheritance of Parameter slots (attributes) from the owning-class' class hierarchy (see ParameterizedMetaclass). NT)rKrirrrrrrrr_set_instantiater_set_allow_Nonerrrs r7rzParameter.__init__sl  $&$  D(>> 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() r) reactive_ops)reactiver)rrs r7rxz Parameter.rxsF +D!!rPct|jr!|jt|jS|jSrb)rKrlabel_formatterrs r7rzParameter.label5s+ 99,"499- -;; rPc||_yrb)rrrs r7rzParameter.label<s  rPct|jd|_y|tur||_y|jd|_y)NTr)rrrlr)rrs r7rzParameter._set_allow_None@s6 << "DO y ((DO"11,?DOrPct|jrd|_y|tur||_y|jd|_y)z)Constant parameters must be instantiated.FrN)rrrlr)rrs r7rzParameter._set_instantiateLs8 ==$D   )*D  $22=AD rPc|dk(rt|dd}|||k7r td||jjv}|dk7xr|t|dgv}|s|st|||St||t }|r |j|||t||||r|t ur|j|||yyy#t$rY;wxYw)NrKzMParameter name cannot be modified after it has been bound to a Parameterized.rr) rhAttributeErrorrrr __setattr__NotImplemented_on_set_trigger_event)r attributerrKis_slot has_watcherrrs r7rzParameter.__setattr__Ys  4.DETM$&MNNt~~9999,[gdJXZ>[1[ ;7&y%8 8dI~6   YU3 Iu- 3n4    3 65; "  s<B?? C  C c Nt||jd|j||d}|j|D](}|jjj ||*|jjj s%|jjjyy)NrJrKrrrrmr})rrKrirr? _call_watcherrr)rrrrmeventwatchers r7rzParameter._trigger_eventrs~9499$DJJ3T3}}Y/G JJ   * *7E :0zz,, JJ   1 1 3-rPctj||}|tur5|dk7r0t|dd# |j|}t|r||}|S#t $r,}t d|d|j jd|d}~wwxYw)z Allow slot values to be Undefined in an "unbound" parameter, i.e. one that is not (yet) owned by a Parameterized object, in which case their value will be retrieved from the _slot_defaults dictionary. rKNSlot z on unbound parameter 1 has no default value defined in `_slot_defaults`) objectrrlrhrrrrr)rrrxrps r7rzParameter.__getattribute__zs  # #D# . >cVmfd0K0S '', {dG C7"89P9P8STGG sA B 'BB cy)zl Can be overridden on subclasses to handle changes when parameter attribute is set. Nr^)rrrrs r7rzParameter._on_setrPcy)z Can be overridden on subclasses to update a Parameter state, i.e. slot values, after the slot values have been set in the inheritance procedure. Nr^rs r7 _update_statezParameter._update_staterrPc||j}|S |jj|j}|S#tt f$r|j}Y|SwxYw)ah Return the value for this Parameter. If called for a Parameterized class, produce that class's value (i.e. this Parameter object's 'default' attribute). If called for a Parameterized instance, produce that instance's value, if one has been set - otherwise produce the class's value (default). )rrrrKrr)rrobjtyperesults r7r zParameter.__get__sc ;\\F  &,,33DII> #H- &  &s#7AAc |j}||jr|jjr||jjv}|j j ||\}}}}|jj}|'|jj j||nT||vrP|sN||=||jjvr3|jjj|j|s|turyt|dr@|j||}|jt urt#j$dt&d|j)|t*} |j,s |j.r|j.rt1d|z||j2} ||_ng|jjs^|jj4j7|j|j2} ||jj4|j<n|jj4j7|j|j2} || urt1d|z||j2} ||_nt9|jt:s.t;t=|jj>|_|jj4j7||j2} ||jj4|<|jA|||?t|d rtC|jd d sy|j jE|||jFj7d } n`||jjFvrF|jjF|j7d } | |jFj7d } nd} | |jn|}|| sytId |||j| |d } tK| dD]} |j jM| |  |j jNs|j jQyy)a8 Set the value for this Parameter. If called for a Parameterized class, set that class's value (i.e. set this Parameter object's 'default' attribute). If called for a Parameterized instance, set the value of this Parameter on that instance (i.e. in the instance's `values` dictionary located in the private namespace `_param__private`, under the parameter's name). If the Parameter's constant attribute is True, only allows the value to be set for a Parameterized class or on uninitialized Parameterized instances. If the Parameter's readonly attribute is True, only allows the value to be specified in the Parameter declaration inside the Parameterized source code. A read-only parameter also cannot be set on a Parameterized class. Note that until we support some form of read-only object, it is still possible to change the attributes of the object stored in a constant or read-only Parameter (e.g. one item in a list). Nset_hookz$Number.set_hook has been deprecated.r,z+Read-only parameter '%s' cannot be modifiedz*Constant parameter '%s' cannot be modifiedexplicit_no_refsrrFrr c|jSrbrws r7z#Parameter.__set__..sallrPr))rKrrrrr? _resolve_refrri _update_ref async_refsrcancelrlrZrrr1r2r3 _validaterrrrrrr3rX_InstancePrivater}r _post_setterrh _update_depsrrrr rr) rrrrKrrefr[is_asyncr_oldrr r s r7r!zParameter.__set__s6yy ?t33F3F3R3Rc11999G'*yy'='=dC'H $CsH&&++D   ,,T37gJ3..999''2266t<CCE3)+ 4 $--S)C}}N2 :0  s ==DMM}} MPT TUU||" ((44**1155diiN8;##**4995**1155diiNd?#$PSW$WXX{||" "#"5"57GH*:)-c)B)B)S)S+C'**1155dDLLI36##**40 #s# ?3 12'#BUBUWdfk:l II " "4 ( ;}}((1H S((11 1**33D9==gFH==,,W5HKdjjS ;h 73DJJCd4h,BCG II # #GU 3Dyy%% II * * ,&rPcy)z)Implements validation for parameter valueNr^)rrrs r7_validate_valuezParameter._validate_value rrPc<|j||jy)z rPct|r|yt|ts#tt|dt |dy)Nz) only takes a string value, not value of rA)rXrr@r"r})rrrs r7r/zString._validate_valueqsH #+ #s#)$/01 $S {!- $rPct|j||j|j||jyrb)r/rrMrIrs r7r'zString._validatezs* S$//2 S$**-rP)r?)rrrrrr~rYrrDrErrrlrMr/r'rrs@r7rHrHFs  I)22BdKN __ ! 55TeRVe    (%9% % .rPrHc$eZdZdZdZiZdZdZy)shared_parametersa Context manager to share parameter instances when creating multiple Parameterized objects of the same type. Parameter default values are instantiated once and cached to be reused when another Parameterized object of the same type is instantiated. Can be useful to easily modify large collections of Parameterized objects at once and can provide a significant speedup. Fcdt_y)NT)rQ_sharers r7 __enter__zshared_parameters.__enter__s #' rPc0dt_it_yNF)rQrS _shared_cache)rexc_typeexc_valexc_tbs r7__exit__zshared_parameters.__exit__s#( *,'rPN)rrrrrSrWrTr[r^rPr7rQrQsFM(-rPrQc.tfd}|S)z Decorator: call fn with the parameterized_instance's initialization flag set to False, then revert the flag. (Used to decorate Parameterized methods that must alter a constant Parameter.) c|j}|jj}d|j_|g|i|}||j_|SrV)rrr)self_rnr`parameterized_instanceoriginal_initializedretfns r7override_initializationz1as_uninitialized..override_initializationsV!&5EEQQ=B..:$$$=Q..: rP)r)rbrcs` r7as_uninitializedrds# 2Y #"rPc eZdZdZej ejeeje eje dejdejiZ e ejiZ edZedZedZy)rna Comparator defines methods for determining whether two objects should be considered equal. It works by registering custom comparison functions, which may either be registed by type or with a predicate function. If no matching comparison can be found for the two objects the comparison will return False. If registered by type the Comparator will check whether both objects are of that type and apply the comparison. If the equality function is instead registered with a function it will call the function with each object individually to check if the comparison applies. This is useful for defining comparisons for objects without explicitly importing them. To use the Comparator simply call the is_equal function. Nct|dS)Nrrrs r7r"zComparator.s '!34rPc4|jj}|jjD]\}}|D]}|||< |jD]Z\}} t ||xr t ||} | r |||cSt |t s?||sH||sQ|||cSt |tttfr|j||St |tr|j||Sy#t $rYwxYwrV) equalitiesrgen_equalitiesrlrXrrr{rr|compare_iteratorr~compare_mapping) robj1obj2equalsgenopr8eq_typeeq are_instancess r7rozComparator.is_equals$$&))//1GCUq 2"<<>KGR * *4 9 Wjw>W !dD>)'<0WT]wt}$~%* dT3. /''d3 3 d #&&tT2 2  s%D  DDct|t|ust|t|k7ryt||D]\}}|j||ryyNFT)r}r=rro)rrmrno1o2s r7rkzComparator.compare_iteratorsN :T$Z '3t9D +A$oFB<<B'&rPct|t|ust|t|k7ry|D]"}||vr|j||||r yyyrv)r}r=ro)rrmrnrzs r7rlzComparator.compare_mappingsU :T$Z '3t9D +A%ADy||DGT!W5   rP)rrrrnumbersNumberoperatorrsrbytesr}rir8rjrrorkrlr^rPr7rnrns$   X[[ x{{ T HKK4hkk J 8;;N,rPrnc(eZdZdZdddZdZdZy)_ParametersRestorerzHContext-manager to handle the reset of parameter values after an update.N)rcB||_||_|i|_y||_yrb) _parameters_restore_refs)rrrestorers r7rz_ParametersRestorer.__init__s"% Z=dfd?Z>e$d@e%#dgdAZ?dgdBZ@dCZAdDZBdEZCdgdFZDe$dGe%#dHZEdIZFdhdJZGdidKZHdjdLZIdkdMZJdNZKdjdOZLe$dPe%#dQZMdRZNe$d"e%#dSZOdTZPe$dUe%#dVZQe$dWe%#dXZRe$dYe%#dZZSd[ZTd\ZUd]ZV dld^ZWeXe" dld_ZYxZZS)m Parametersaa Object that holds the namespace and implementation of Parameterized methods as well as any state that is not in __slots__ or the Parameters themselves. Exists at both the metaclass level (instantiated by the metaclass) and at the instance level. Can contain state specific to either the class or the instance as necessary. c ||_||_y)zj cls is the Parameterized class which is always set. self is the instance if set. N)rr)r^rrs r7rzParameters.__init__ s   rPcH|jjjdSNr self_or_clsrparameters_stater^s r7rzParameters._BATCH_WATCHs  00AA-PPrPcJ||jjjd<yrrr^rs r7rzParameters._BATCH_WATCHsLQ))::=IrPcH|jjjdSNTRIGGERrrs r7_TRIGGERzParameters._TRIGGERs  00AA)LLrPcJ||jjjd<yrrrs r7rzParameters._TRIGGER!sHM))::9ErPcH|jjjdSNrrrs r7rzParameters._events%s  00AA(KKrPcJ||jjjd<yrrrs r7rzParameters._events)sGL))::8DrPcH|jjjdSNrrrs r7rzParameters._state_watchers-s  00AA*MMrPcJ||jjjd<yrrrs r7rzParameters._state_watchers1sIN)):::FrPcp|j td|jjjS)z Dictionary of instance watchers.zUAccessing `.param.watchers` is only supported on a Parameterized instance, not class.rrrrrs r7rzParameters.watchers5s0 :: st tzz))222rPch|j td||jj_y)NzSSetting `.param.watchers` is only supported on a Parameterized instance, not class.rrs r7rzParameters.watchers<s* :: qr r.3 ""+rPcJ|j |jS|jSrb)rrrs r7rzParameters.self_or_clsBs!JJ.uyy>EJJ>rPc8|jd|jd}}||n|}|jjD]4}d|z}||vs |j||jj|<6|j D]\}}t |||y)Nrrrg)r3rrrrlr)rr?r^rrrzrrxs r7r@zParameters.__setstate__FsYYv& %(8s$0ec ,,==Aa%Ce|BG))C. ++<KKMDAq D!Q "rPc~|j}||j|S|jd|}t||S)z'Returns the class or instance parameterFr)r_cls_parametersrr)r^rrTrs r7 __getitem__zParameters.__getitem__QsCzz <((- - MM5M )# .&tQ//rPcLt|t|jzS)zAdds parameters to dir)r__dir__r{r)r^rs r7rzParameters.__dir__Ys w 4(=(=#>>>rPc#8K|jEd{y7w)z,Iterates over the parameters on this object.Nrrs r7__iter__zParameters.__iter__]s((((s c||jvSrbr)r^r?s r7 __contains__zParameters.__contains__as----rPc2|jjd}|t||jvr|j |S|j %td|j jd|td|j jd|)z.Extends attribute access to parameter objects.rz type object 'z.param' has no attribute 'z .param' object has no attribute )rr3rrrrrr)r^rrs r7 __getattr__zParameters.__getattr__dsnn  ' ; 5(( ($$T* * ZZ  =1C1C0DD]^b]e!fg g 1UYY%7%7$88XY]X`!ab brPc&||j_yrbrrK)r^rKs r7 _set_namezParameters._set_nameqs  rPc`|jd|jjtfzy)Nz%s%05d)rrr object_countrs r7_generate_namezParameters._generate_nameus" EII$6$6 #EEFrPc |j}i}i}|j}|jD]4\}}|jr |dk7r|||<|js*|dk7s0|||<6|j D]}|j ||j D]}|j |dii} }|jD]1\} } |jj| d} | s$t|jjd| |j| } | | js| |jjjvrP |j!| | \}}}}|r6t%j&d| d| j(d | d | d d t*d t-|| | |j!| | \}}}}| || | <||| <|r|t.ur|t0ur%t-|| |4| |fS#t"$rd}YwxYw)a Initialize default and keyword parameter values. First, ensures that values for all Parameters with 'instantiate=True' (typically used for mutable Parameters) are copied directly into each object, to ensure that there is an independent copy of the value (to avoid surprising aliasing errors). Second, ensures that Parameters with 'constant=True' are referenced on the instance, to make sure that setting a constant Parameter on the class doesn't affect already created instances. Then sets each of the keyword arguments, raising when any of them are not defined as parameters. rKF)deepcopyrz/.__init__() got an unexpected keyword argument Nz Parameter z on z, is being given a valid parameter reference zg but is implicitly allow_refs=False. In future allow_refs will be enabled by default and the reference z* will be resolved to its underlying value zv. Please explicitly set allow_ref on the Parameter definition to declare whether references should be resolved or not.r,)rrrlrrr_instantiate_paramrget_param_descriptorrrrr3rrrr#rr1r2rir3rrlr)r^rrparams_to_deepcopy params_to_refrrrr[rrKrdescrcr+rgreref_depsr,s r7 _setup_paramszParameters._setup_paramsysDzz '' HE1}}&,-"5)'( e$ ( $**,A  $ $Q '-%%'A  $ $Q $ 7(dID#9911$7:D~~../0((,x1 ;;t$D|4?? uyy88III#.3.@.@s.K+Q! (TZZLA)),.--0E2%%-J/9 9&9'( dC(160B0B40M -C8X T %T X%:h$>NdH-Q(RTz1%#"#sG?? H  H c btt}|jD]\}}|D]w}t|tr+||j j ||jf>t|D],}||j j ||jf.y|jD]y\}}t|\} }|jjjj | |jj|jtt!|df{y)Nrr)rr{rlrXrYrirSrKrsrrr ref_watchersr?_watch _sync_refsr) r^rgroupsrsubrefsrrwripnamesrefnamess r7 _setup_refszParameters._setup_refssT""jjlNE7a+177O**E166?;215rxx(//0@A6 +$\\^ME6"F| Hf JJ & & 3 3 : : ""5#3#3T#f+5FSU"V< ,rPc|jj}||jvr)|jj|j |j D]D\}}|j |jn |j }|jj|Fg|jj_t|jjjfi||i}|jDcic]\}}|t|}}}|j|||jj_ ycc}}wrb)rrr%rr&rrTrr?unwatchr~rrlrr) r^rKr+ param_privatergr dep_objrr[s r7r$zParameters._update_refs 22 =++ +  $ $ ( ( . 5 5 7'44JAw%,\\%9gkkw||G MM ! !' *535 ""/EJJ..33Cc{C8< E 94k#&& E $*. ""'Fs;Eci}|jjjjD]\}}||j}t ||}t j|}t|xs|}tfd|Ds|s\ t||} | tus| turz|r!tt|j|| | ||<t!|j5t#|j|5|j%|ddddddy#t$r t} YwxYw#1swY'xYw#1swYyxYw)Nc3K|]>}D]7}|j|juxr|j|jk(9@ywrb)rirrK)rcrjrprs r7rez(Parameters._sync_refs..s@cds\bWX QUU*Asxx166/AA\bAdsAA)rrrrlrrrrr$rkrwrrlr*r _async_refrrrA) r^rupdatesrr+rr[rr,new_vals ` r7rzParameters._sync_refss%**4499??AJE3e 00IsI.D005F*3/96Hcdcclt $'Y7$'Y"6wu'7'7HI$GEN'B*5:: &%**g. W%/' & $# $/.' &s6 D%+ED:E%D76D7:E ?EEcVtj|}t|xs|}t||j}|s |s|sdd|dfS|} t ||j}|r,tt|j|j|d}||||fS#t $r t}YEwxYw)N)rF) rrr$rrrwrrlr*rrrK)r^rcrrr,r[r+s r7r#zParameters._resolve_refs,,U3&u-75D,<,<=Fue+ + !%43C3CDE  75#3#3TYYF GED%))  E s BB('B(cK|jjjs!tt |j ||yt j}|jjjj|}|$||jjj|<n5||ur1|jjj|j t|tjr?|23d{}t|j|f5|j||iddd=t|j|f5 |j||d{iddd|jjjj||ur"|jjj|=yy7#1swYxYw6d7u#t $rYywxYw#1swY~xYw#|jjjj||ur"|jjj|=wwxYwwrb)rrrr*rrasyncio current_taskr%r3r&rXtypesAsyncGeneratorTyperrAr)r^r awaitabler running_tasknew_objs r7rzParameters._async_ref szz))55 75#3#3UIF G ++- zz11<<@@G  ;GEJJ & & 1 1% 8  - JJ & & 1 1% 8 ? ? A A)U%=%=>%.7'!%**uh7 eW%5687ejj5(3 e9_%=>4zz))4488?<OJJ..99%@P777&/ .=43zz))4488?<OJJ..99%@PsC I#G9?GG GG9G3 G9G-G&G ' G0G98AI GG  G9G G*'G-)G**G--G62G99AIIcXtj|j|j S)zu Predicate that determines whether a Event object has actually changed such that old != new. )rnrorrm)rr s r7_changedzParameters._changed(s" &&uyy%))<<.4srPr)rrrrrrKrQrSrr}rWrrX Parameterizedrr?r) r^ param_objdict_rr instantiatorr param_key new_objects r7rzParameters._instantiate_param0s)1t}}k zz4--44#Y^^  # #T$Z)..9I-;;;.< 0rPc |j}g}t|jjdD]0\}}}}} | D cgc](} |"| jj dd|k(s'| *} } |rt t} t||gD]K} | t| jt| j| jfjd| fM| jD]} |j|||| t!|j|}|r||vr|j|nm| ri|j"j$j'|gD]?}|j |jn |jjj)|Anmt t}| D]^}t|g|gD]K} |t| jt| j| jfj|| fM`|jD]?} |j|||| |}|j"j$|j|A3|D] }| ycc} w)NwatchrAr)rr}r?_dependsrPrrr{riidrTrrJrSr _watch_grouprhrdynamic_watchersrr)r^rinitr init_methodsrqueuedon_initrrYrdconstant_groupedrjrOrQr!groupedddepr s r7r*zParameters._update_depsKs'jj :>s)//:R:RSZ:[ 6FFGXw#*d'QY->!&&,,sBSTUBVZcBcq'Gd#.t#4 ,S(B?C$blBswwK%JKRRTXZ]S^_@-446E&&sFFEB7EJJ/q 4 ''*,,==AA&"MAffnQUU!&&??GGJN"$'G,S"tf=CR\2cgg;ABII4QT+V> !),,S&&%S##44V<CCGL*3;\8A C3es (I4(I4c}g}|jjdddD]2}t||jddd}|j|4|j |j n |j}||ddvrdd|j fS|j|} d} | dkDrfd} dj|jjddjd| dzd} | dk(r&t|djD cgc]} | } } n| g} d|jvr|jjdd}n |j }| | |fScc} w) a If a subobject whose parameters are being depended on changes we should only trigger events if the actual parameter values of the new object differ from those on the old subobject, therefore we accumulate parameters to compare on a subobject change event. Additionally we need to make sure to notify the parent object if a subobject changes so the dependencies can be reinitialized so we return a callback which updates the dependencies. rANrrIrc<jjy)z If a subobject changes, we need to notify the main object to update the dependencies. N)r?r*)rrrs r7ryz2Parameters._resolve_dynamic_deps..callbacks  &&y1rPrr?) rPrrhrSrTrrJrrr{r?)rr dynamic_dep param_deprsubobjsubobjssubpathrdepthryrrw subparamsrJs ` ` r7_resolve_dynamic_depsz Parameters._resolve_dynamic_depsmsf%"''--c23B7GVW]]3%7%:DAF NN6 "8$->>#9)--y~~ '#2, &y~~- - g& 19 2 HH[%%++C0399#>uQwxH I <&*72;+<+<&=>&=&=I>I +"" "##))#.r2D>>D(D((?s E!c|d\}}|j |jn |j}g} |D]/\} } | j| vs| j| j1|dd|j}} } n|j ||||\} } }t |||| | }|jj|| |j|dS)ab Sets up a watcher for a group of dependencies. Ensures that if the dependency was dynamically generated we check whether a subobject change event actually causes a value change and that we update the existing watchers, i.e. clean up watchers on the old subobject and create watchers on the new subobject. rNr)rr) rTrrKrSrJrrr?r)r^rrKrrOrrrrrrggrryrJmcallers r7rzParameters._watch_groups"'q Y#,>>#9)--y~~DAqvvV# aff%  (,dINNxI(-(C(C[)Y)8 %IxCtYA}}## VY^^Fr$K KrPc.t|j|Srb)_parameterized_repr_htmlr)r^opens r7 _repr_html_zParameters._repr_html_s'(9(94@@rPzfUse instead `for k,v in p.param.objects().items(): print(f"{p.__class__.name}.{k}={repr(v.default)}")`rc|j}|jjD]J\}}t|tst |j dz|zdzt|jzLy)z Print the default values of all cls's Parameters. .. deprecated:: 1.12.0 Use instead `for k,v in p.param.objects().items(): print(f"{p.__class__.name}.{k}={repr(v.default)}")` rArN) rrrlrXrYprintrreprr)r^rrrs r7print_param_defaultszParameters.print_param_defaultss[ii||))+GC#i(cll3&s*C/ckk1BBC,rPzUse instead `p.param.default =`c6|j}t|||y)z Set the default value of param_name. Equivalent to setting param_name on the class. .. deprecated:: 1.12.0 Use instead `p.param.default =` N)rr)r^ param_namerrs r7 set_defaultzParameters.set_defaultsiiJu%rPr rc|j}tj|||tj ||||j j jy)a Add a new Parameter object to this class. This method allows dynamically adding a Parameter to the class, resulting in behavior equivalent to declaring the Parameter in the class's source code. Parameters ---------- param_name : str The name of the parameter to add. param_obj : Parameter The Parameter object to add. Examples -------- Create a Parameterized class: >>> import param >>> class P(param.Parameterized): ... a = param.Number() ... b = param.String() >>> p = P() Add a new parameter to the class `P` via the class namespace `P.param`: >>> P.param.add_parameter('c', param.Tuple(default=(1, 2, 3))) >>> print(p.c) (1, 2, 3) Add a new parameter to the class `P` via the instance namespace `p.param`: >>> p.param.add_parameter('d', param.Tuple(default=(3, 2, 1))) >>> p.d (3, 2, 1) N)rr}rParameterizedMetaclass_initialize_parameterrrclear)r^r rrs r7 add_parameterzParameters.add_parametersJRii j)444S*iP ""((*rPz"Use instead `.param.add_parameter`c&|j||S)zg Add a new Parameter object into this object's class. .. deprecated :: 1.12.0 )r)r^r rs r7_add_parameterzParameters._add_parameter s"":y99rPz2Use instead `.param.values()` or `.param['param']`c8|jd}||S||S)a Return the Parameters of this class as the dictionary {name: parameter_object} Includes Parameters from this class and its superclasses. .. deprecated:: 1.12.0 Use instead `.param.values()` or `.param['param']` rr)r)r^parameter_namepdicts r7rzParameters.params s* z 2  !L( (rPc xi}|j|jj}t|tur|n t |fi|}|D]I}||vr||j vr|j |||<)||j vs8|j |||<Kt |j|fi|}t|||S)a Update multiple parameters of this object or class before triggering events. Allows setting the parameters of the object or class using a dictionary, an iterable, or keyword arguments in the form of `param=value`. The specified parameters will be updated to the given values. This method can also be used as a context manager to temporarily set and then reset parameter values. Parameters ---------- **params : dict or iterable or keyword arguments The parameters to update, provided as a dictionary, iterable, or keyword arguments in `param=value` format. User Guide ---------- https://param.holoviz.org/user_guide/Parameters.html#other-parameterized-methods Examples -------- Create a Parameterized class: >>> import param >>> class P(param.Parameterized): ... a = param.String() ... b = param.String() Define the instance: >>> p = P(a="0. Hello", b="0. World") Use `.update` to update the parameters: >>> p.param.update(a="1. Hello", b="2. World") >>> p.a, p.b ('1. Hello', '1. World') Update the parameters temporarily: >>> with p.param.update(a="2. Hello", b="2. World"): ... print(p.a, p.b) 2. Hello 2. World >>> p.a, p.b ('1. Hello', '1. World') Lets see that events are triggered **after** all parameters have been updated >>> @param.depends(p.param.a, watch=True) ... def print_a_b(a): ... print(p.a, p.b) >>> my_param.param.update(a="3. Hello",b="3. World") 3. Hello 3. World )rrr) rrr{rlr~rr%rr)r^r[rorprivaterrrs r7rAzParameters.update$ sn :: !jj00GC9$4&$s:Mf:MNFD=gll*"),,u"5DKg000")"4"4U";DK  }u}}S3F34"eW4PPrPc |j}d|_|j}|tur t|fi|}|Dcgc]}||vrt ||dr|}}|D] }d||_|j }|jD cic]\}} ||vs |||} }} |jD]B\}} ||vr+d|_t|d|jj t||| D||_|s|j|D],}||} d| _t||| jd| _.| Scc}wcc} }w#t$r d|_wxYw)NT_autotrigger_valuerFz is not a parameter of resetz set-reset)rrrlr~rZ_moderrlr@rrrrr_autotrigger_reset_value) r^r[rorrrztrigger_paramstprrxrrs r7rzParameters._updatei s(( !'' i #((F !EzgeAh0DE v  !B#E"IO!,2LLNJNDAqa6k1fQi15::++A..>> ?s !C2cF|j+|jjjs td|Dcgc]}t ||dr|}}|Dcic]}||vr|||j }}|j }|j}g|_g|_|j}|Dcic]}||| } }d|_ |jt| fi|d|_ |xj |z c_|xj|z c_ycc}wcc}wcc}w)ad Trigger watchers for the given set of parameter names. Watchers will be triggered whether or not the parameter values have actually changed. As a special case, the value will actually be changed for a Parameter of type Event, setting it to True so that it is clear which Event parameter has been triggered. NzTriggering watchers on a partially initialized Parameterized instance is not allowed. Ensure you have called super().__init__(**params) in the Parameterized instance constructor before trying to set up a watcher.rTF) rrrrrZrrrrrrAr~) r^ param_namesrrtriggersrr param_valuesrKrs r7triggerzParameters.trigger s> :: !%***D*D*P*P\  &+FU$U1X/CDUF,A+qK/?eAh111+ A(( "||~ 7BC{t$ T**{C T&-H-.   )FADsDD1 Dc |rd}n|jrdnd}t|j|j|j|j |j |j|S)zFReturns an updated Event object with the type field set appropriately. triggeredrkrr ) onlychangedrrJrKrrrrm)r^r r r* event_types r7_update_event_typezParameters._update_event_type sO $J&-&9&9uJ%**5::599%)) D DrPcr|jdk(r|i}}n&d|Dcic]}|j|j}}}t|jrAt t d|jzt t|jg|i|y |j|i|ycc}w#t$rYywxYw)Nrnr^zCould not execute %s coroutine function. Please register a asynchronous executor on param.parameterized.async_executor, which schedules the function on an event loop.) rrKrmr$rbr*rrr)rr rrnror s r7_execute_watcherzParameters._execute_watcher s <<6 !!2&D6J6% EII 56&JD wzz *%"$N$+:: $.// 77::??? @  D+F+ K  sB%B** B65B6c|jrnjr|j|sy|jrV|jj |t fd|jDs|jj yy|j||j}t|jjd5|j|fdddy#1swYyxYw)z=Invoke the given watcher appropriately given an Event object.Nc3&K|]}|u ywrbr^)rcr!r s r7rez+Parameters._call_watcher..' sC-Bw!|-BsFrr) rr+rrrrSrkrr-rrrr/)r^r r s ` r7r zParameters._call_watcher s >>   %..*?     MM  'CU-B-BCC%%,,W5D,,WeU^^LE%e&7&7TYZ&&w9[ZZs C++C4c ^|jr t|jDcgc]}|j|jf|fc}}|jdd}g|_g|_t |dD]}|j Dcgc]>}||jf|vr,|j||||jf|j@}}t|j|jd5|j||ddd|jr yycc}wcc}w#1swYxYw)z Batch call a set of watchers based on the parameter value settings in kwargs using the queued Event and watcher objects. Nc|jSrbrr s r7r"z1Parameters._batch_call_watchers..: s!,,rPrFr2) rrrKrJrrparameter_namesr-rrrrr/)r^r  event_dictrr rKrs r7rzParameters._batch_call_watchers. s, mm$38==&B3@%). EJJ'?&G3@&BCJ,,Q/HEM$&E !!(0FG'.&=&=A&=d"GLL1Z? 227JgllG[<\38>>C&=A*%*;*;GNNX]^**7F;_^ Hmm&BA_^s!DAD,D##D, c|j}||_t|trd|f}n|f}|jj dj D]D\}}t|ds|j|s#|jj|}||_F|r1 t||}|D]} | jj|| yy#t$rg}Y2wxYw)a Set time_fn for all Dynamic Parameters of this class or instance object that are currently being dynamically generated. Additionally, sets _Dynamic_time_fn=time_fn on this class or instance object, so that any future changes to Dynamic Parmeters can inherit time_fn (e.g. if a Number is changed from a float to a number generator, the number generator will inherit time_fn). If specified, sublistattr is the name of an attribute of this class or instance that contains an iterable collection of subobjects on which set_dynamic_time_fn should be called. If the attribute sublistattr is present on any of the subobjects, set_dynamic_time_fn() will be called for those, too. Nr_value_is_dynamic) r_Dynamic_time_fnrXr}r?rrlrZr8get_value_generatorrhrset_dynamic_time_fn) r^time_fn sublistattrrarrrrsublistrs r7r;zParameters.set_dynamic_time_fnB s$'' '. $ k$ 'k"AA$$,,Z8>>@CAaq-.&1&&*#))==a@A)0A& A  !+k: --gkB "  s C CCc |j}|tjvr6td|dt tjj tj|}|j ||S)a( Return the serialized parameters of the Parameterized object. Parameters ---------- subset : list, optional A list of parameter names to serialize. If None, all parameters will be serialized. Defaults to None. mode : str, optional The serialization format. By default, only 'json' is supported. Defaults to 'json'. Returns ------- Any The serialized value. User Guide ---------- https://param.holoviz.org/user_guide/Serialization_and_Persistence.html#serializing-with-json Examples -------- Create a Parameterized instance and serialize its parameters: >>> import param >>> class P(param.Parameterized): ... a = param.Number() ... b = param.String() >>> p = P(a=1, b="hello") Serialize parameters: >>> serialized_data = p.param.serialize_parameters() >>> print(serialized_data) {"name": "P00002", "a": 1, "b": "hello"} rrr)rrYrr@r{rserialize_parameters)r^rrrrs r7rBzParameters.serialize_parametersk ssJ'' y-- -uTH,TUYZcZpZpZuZuZwUxT{|} }++D1 .z..{6JJrPc |j}|tjvr6td|dt tjj tj|}|j ||SNrr)rrYrr@r{rserialize_parameter_value)r^rrrrs r7serialize_valuezParameters.serialize_value sp'' y-- -uTH,TUYZcZpZpZuZuZwUxT{|} }++D1 3z33KGGrPreturncj|j}tj|}|j|||S)a* Deserialize the given serialized data. This data can be used to create a `Parameterized` object or update the parameters of an existing `Parameterized` object. Parameters ---------- serialization : str The serialized parameter data as a JSON string. subset : list of str, optional A list of parameter names to deserialize. If `None`, all parameters will be deserialized. Defaults to `None`. mode : str, optional The serialization format. By default, only 'json' is supported. Defaults to 'json'. Returns ------- dict A dictionary with parameter names as keys and deserialized values. User Guide ---------- https://param.holoviz.org/user_guide/Serialization_and_Persistence.html#serializing-with-json Examples -------- >>> import param >>> class P(param.Parameterized): ... a = param.Number() ... b = param.String() ... >>> serialized_data = '{"a": 1, "b": "hello"}' >>> deserialized_data = P.param.deserialize_parameters(serialized_data) >>> print(deserialized_data) {'a': 1, 'b': 'hello'} >>> instance = P(**deserialized_data) rA)rrYrdeserialize_parameters)r^ serializationrrrrs r7rIz!Parameters.deserialize_parameters s8N'' ++D1 0z00mTZ[[rPc |j}|tjvr6td|dt tjj tj|}|j |||SrD)rrYrr@r{rdeserialize_parameter_value)r^rrrrrs r7deserialize_valuezParameters.deserialize_value sr'' y-- -uTH,TUYZcZpZpZuZuZwUxT{|} }++D1 5z55k5%PPrPc |j}|tjvr6td|dt tjj tj|}|j |||S)zAReturns a schema for the parameters on this Parameterized object.rrr)rrYrr@r{rr)r^rrrrrs r7rzParameters.schema sr'' y-- -uTH,TUYZcZpZpZuZuZwUxT{|} }++D1  z  4GGrPz Use `.param.values().items()` instead (or `.param.values()` for the common case of `dict(....param.get_param_values())`) cz|j|}|jDcgc] \}}||f c}}Scc}}w)a Return a list of name,value pairs for all Parameters of this object. When called on an instance with onlychanged set to True, will only return values that are not equal to the default value (onlychanged has no effect when called on a class). .. deprecated:: 1.12.0 Use `.param.values().items()` instead (or `.param.values()` for the common case of `dict(....param.get_param_values())`) )rrl)r^r+valsrzrxs r7get_param_valueszParameters.get_param_values s8"||K(#'::<0<41aA<000s7c|j}g}|jjdjD]~\}}|jj |}|dk(r#|r!t |j j|rI|r!tj||jrl|j||f|jtdt|S)a* Return a dictionary of name,value pairs for the Parameters of this object. When called on an instance with onlychanged set to True, will only return values that are not equal to the default value (onlychanged has no effect when called on a class). rrKrr)rr?rrlr:rrrrnrorrSsortr r~)r^r+rrPrKrrs r7rzParameters.values s'' $**22:>DDFID#%%99$?Ev~+- @R@RTY2Zj&9&9%&M T5M* G jm $DzrPc|j}|jjdj|}|s t ||Sd\}}t |t r|}n|}t|ds|j||S|j||S)z Force a new value to be generated for the dynamic attribute name, and return it. If name is not dynamic, its current value is returned (i.e. equivalent to getattr(name). rNN_force) rr?rr3rhrXr}rZr rV)r^rK cls_or_slfrrslfs r7force_new_dynamic_valuez"Parameters.force_new_dynamic_value s&& $$,,Z8<s r7r:zParameters.get_value_generator s&& $$,,Z8< s&& $$,,Z8<C{12w}}S) t9>l"G"G!/g")#2,"+E,=,=sxx?PRV"W"/g%*%7%7HHT/3w<>%:;Wl&T <6#9RQQ4@P?QQQ#-c4#8S$KtCy#>N T 7?!&!3!3CGWl!S D,YY141G1G7T`1a. . " 22 % % SYY d$!iioD:D S$ sD)H(M22v H|Z&@A$Cd$,.%z$9STWSXXY%Z[[ S*d +\V3rK K%T:J9KK K :dX5OPSuTU!VW W ;l62: "//AB,Ol 6 ! KK \!!rPcD|j+|jjjs td|j}|D]}||j j vr/tdj||j j|jV|dk(rQ|jjj}||vri||<|||vrg|||<t|||||||j}||vrg||<t||||y)Nz(Un)registering a watcher on a partially initialized Parameterized instance is not allowed. Ensure you have called super().__init__(**) in the Parameterized instance constructor before trying to set up a watcher.z<{} parameter was not found in list of parameters of class {}r) rrrrr5rr?r@r6rrrh)r^actionr rJr5rrs r7_register_watcherzParameters._register_watcher s+ :: !%***D*D*P*PX  "11-NUYY__4 "::@&QVQZQZQcQc:dffzz%$'/ ::55>>!1/1H^,x7757H^,T2?06?H 099x'%'HTN//8!.rPcN|dkr td|j||||||S)a Register the given callback function `fn` to be invoked for events on the indicated parameters. `what`: What to watch on each parameter; either the value (by default) or else the indicated slot (e.g. 'constant'). `onlychanged`: By default, only invokes the function when the watched item changes, but if `onlychanged=False` also invokes it when the `what` item is set to its current value again. `queued`: By default, additional watcher events generated inside the callback fn are dispatched immediately, effectively doing depth-first processing of Watcher events. However, in certain scenarios, it is helpful to wait to dispatch such downstream events until all events that triggered this watcher have been processed. In such cases setting `queued=True` on this Watcher will queue up new downstream events generated during `fn` until `fn` completes and all other watchers invoked by that same event have finished executing), effectively doing breadth-first processing of Watcher events. `precedence`: Declares a precedence level for the Watcher that determines the priority with which the callback is executed. Lower precedence levels are executed earlier. Negative precedences are reserved for internal Watchers, i.e. those set up by param.depends. When the `fn` is called, it will be provided the relevant Event objects as positional arguments, which allows it to determine which of the possible triggering events occurred. Returns a Watcher object. See help(Watcher) and help(Event) for the contents of those objects. ryUser-defined watch callbacks must declare a positive precedence. Negative precedences are reserved for internal Watchers.)r@r)r^rbr5rJr+rrs r7rzParameters.watch s<J >CD D||B{FJWWrPc t|tr t|n|f}t|j|j |d||||| }|j d|||S)Nrn rTrrbrr+r5rJrrrS)rXr{r|rrrrur^rbr5rJr+rrr s r7rzParameters._watch4 s\4>PT4U%0\k[muzzuyyRf&1?#FzK '48rPc |jd||jy#t$r!|jdt |dYywxYw)zYRemove the given Watcher object (from `watch` or `watch_values`) from this object's list.remove)rJzNo such watcher z to remove.N)rurJrwarningr)r^r s r7rzParameters.unwatch< sL H  # #HgGLL # I H MM,S\N+F G Hs!'A  A c |dkr td|dk(sJt|tr t|}n|f}t |j |j |d||||| }|jd|||S)a Easier-to-use version of `watch` specific to watching for changes in parameter values. Only allows `what` to be 'value', and invokes the callback `fn` using keyword arguments = rather than with a list of Event objects. rrwrroryrS)r@rXr{r|rrrrurzs r7 watch_valueszParameters.watch_valuesC s >CD Dw ot ,#O4O.0OuzzuyyR'[*9!'J@ '48rPz@Use instead `{k:v.default for k,v in p.param.objects().items()}`c|j}i}|jjdjD]K\}}|jr |j r|jj ||||j||<M|S)a2 Return {parameter_name:parameter.default} for all non-constant Parameters. Note that a Parameter for which instantiate==True has its default instantiated. .. deprecated:: 1.12.0 Use instead `{k:v.default for k,v in p.param.objects().items()}` r)rr)rr?rrlrrrr)r^rrdr r?s r7rzParameters.defaults] szzz !%!3!3J!?!E!E!G J~~   --e1*-M!MMAjM "H rPc|j}t|jj|rQtrt trt dz|z}t|jj ||g|i|yy)z Calls the logger returned by the get_logger() function, prepending the result of calling dbprint_prefix() (if any). See python's logging module for details. )rKz: N)rrOrK isEnabledFordbprint_prefixrlog)r^rmsgrnr`rs r7 __db_printzParameters.__db_printv sq'' ;++ , 9 9% @(>":$&-3 1JK,, - 1 1% Jt Jr J ArPc|j}|jjjD]"\}}t |j d|d|$y)z Print the values of all this object's Parameters. .. deprecated:: 1.12.0 Use instead `for k,v in p.param.objects().items(): print(f"{p.__class__.name}.{k}={repr(v.default)}")` rAz = N)rr?rrlrrK)r^rrKrs r7print_param_valueszParameters.print_param_values sNzz**,224ID# TYYKqc#/ 05rPc:|jt|g|i|y)z Print msg merged with args as a warning, unless module variable warnings_as_exceptions is True, then raise an Exception containing the arguments. See Python's logging module for details of message formatting. N)rrr^rrnr`s r7r}zParameters.warning s  '3,,,rPz,Use instead `.param.log(param.MESSAGE, ...)`c:|jt|g|i|y)z Print msg merged with args as a message. See Python's logging module for details of message formatting. .. deprecated:: 1.12.0 Use instead `.param.log(param.MESSAGE, ...)` N)_Parameters__db_printrrs r7messagezParameters.message s  c-4-"-rPz,Use instead `.param.log(param.VERBOSE, ...)`c:|jt|g|i|y)z Print msg merged with args as a verbose message. See Python's logging module for details of message formatting. .. deprecated:: 1.12.0 Use instead `.param.log(param.VERBOSE, ...)` N)rr=rs r7verbosezParameters.verbose s  0d0R0rPz*Use instead `.param.log(param.DEBUG, ...)`c:|jt|g|i|y)z Print msg merged with args as a debugging statement. See Python's logging module for details of message formatting. .. deprecated:: 1.12.0 Use instead `.param.log(param.DEBUG, ...)` N)rrrs r7debugzParameters.debug s  s.D.2.rPc|tur trtd||zztdz a|j||g|i|y)a Print msg merged with args as a message at the indicated logging level. Logging levels include those provided by the Python logging module plus VERBOSE, either obtained directly from the logging module like `logging.INFO`, or from parameterized like `param.parameterized.INFO`. Supported logging levels include (in order of severity) DEBUG, VERBOSE, INFO, WARNING, ERROR, CRITICAL See Python's logging module for details of message formatting. z Warning: rN)rwarnings_as_exceptionsr warning_countr)r^rrrnr`s r7rzParameters.log sK G % cDj 899q 1d1b1rPc|j}t|ts td|jj dj D]\}}|jj|}t|drK|jj|j|jj|jxt|dst|ts|jy)a Save this instance's state. For Parameterized instances, this includes the state of dynamically generated values. Subclasses that maintain short-term state should additionally save and restore that state using _state_push() and _state_pop(). Generally, this method is used by operations that need to test something without permanently altering the objects' state. z1_state_push is not implemented at the class levelr _Dynamic_last _state_pushN)rrXrNotImplementedErrorr?rrlr:rZ_saved_Dynamic_lastrSr_saved_Dynamic_time _Dynamic_timerr^rrrrs r7rzParameters._state_push s  $ .%&YZ Z **:6<<>HE1 ..u5Aq)%%,,Q__=%%,,Q__==)j=.I ?rPc|j}t|ts td|jj dj D]\}}|jj|}t|dr?|jj|_ |jj|_ lt|dsyt|ts|jy)ze Restore the most recently saved state. See _state_push() for more details. z0_state_pop is not implemented at the class levelrr _state_popN)rrXrrr?rrlr:rZrrrrrrrs r7rzParameters._state_pop s   $ .%&XY Y **:6<<>HE1 ..u5Aq)"#"7"7";";"="#"7"7";";"=<(Z--H  ?rPc |j}t|ts tdt |j ||||||S)z (Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details. z,pprint is not implemented at the class level)importsprefix unknown_valuequalify separator)rrXrrr_pprint)r^rrrrrrs r7pprintzParameters.pprint sR   $ .%&TU UZwu}}dGF%2GyZ\ \rPc t|g}tt||dd|j}|jd}|j d|z|j d|dz|j j t}|j j } tt|j} d| jvs| jddk7r"tdt|jd| jdd} | jd| jdt| j } t!t#| jt| j d| j} n| g} } |j j%d t't'|fd  }ggg}}}| |zD] }||vr |d k(r9| |4t)j*d |j,jzdz| |rG|| vrt/| |||g||nd}|#|durt1|j2d|||}|| vr|| vr | || |k(r|| vr|j |nJ|| vs0t5| dr | j6t5| dr"| j8|j |d||j | |r|dznd}||z| j:rd| j:zgngz}|dj=|j,jd|z|zj?|zS)NrA import %sr)r+rrzD.__init__.__signature__' must contain 'self' as its first Parameter.rrcX|j td S|jS)Ninf)rfloat)rzrs r7r"z$Parameters._pprint..7 s5(m66>#5\>4%a=334rPrrK^z[0-9]+$)rsettingsrrFz: unknown value of varkwkeywordsrr?z**%sz{}({}),) r{rrrrSr?rscript_repr_suppress_defaultsrr}rrnrrrr=r~rrrrMrNrrrrKrZrrvarargsr6r)rrrrrrmodbitschanged_paramsrrPrnposargsroorderingarglistrrGrzr qualifier argumentsrs @r7rzParameters._pprint s( ?G#g,' ooyy~{3'{47*+**7T*U""$d4j112  "diilf&<QtDz2233wxy yyy} == $ii 4#dmm"4!45G#diiT]]);(;(<=t}}MNF"BVGZZ'' 3  > "56 (*2r9AI~xF{q 5$&HHS1H1H-H-RTZ[\T]$^01F{6!9gfb)6#*,@D } E)#tyyk1DQE$JKK"*)EV !v+6!9q 3I8G|u%v+4)tzz/E4,$--2K1#Qug/   Q E!H#*C#Ir h&T\\6DLL+@*AWYZ 8??4>>+B+Bc)mTZFZE`E`ajEklllrPrb)NNTrVT)Nr)rrAFTT)r)rTFr)rTFr)N Fr?)[rrrrrrrrFrrrrrr@rrrrrrdrrrrr$rr#rrrrr*rrr rrr3rr rrYrrrrlrArr rrr(r-r/r rr;rBrFr~rIrMrrQrrYr:r_rbrdr9rUrurrrrrrrr}rrrrrrr staticmethodrrrs@r7rrsxQQRRMM__NNLL ^^MMNNOO33 __44 ??  0?). cGGHHT" /&6* A6==.6 D,)\K2AA HVij Dj DC(*GmGmrPrc|eZdZdZdZdZdZdZdZdZ e e Z e eZ dZ e e Zd Zd Zd Zy ) r a, The metaclass of Parameterized (and all its descendents). The metaclass overrides type.__setattr__ to allow us to set Parameter values on classes without overwriting the attribute descriptor. That is, for a Parameterized class of type X with a Parameter y, the user can type X.y=3, which sets the default value of Parameter y to be 3, rather than overwriting y with the constant value 3 (and thereby losing all other info about that Parameter, such as the doc string, bounds, etc.). The __init__ method is used when defining a Parameterized class, usually when the module where that class is located is imported for the first time. That is, the __init__ in this metaclass initializes the *class* object, while the __init__ method defined in each Parameterized class is called for each new instance of that class. Additionally, a class can declare itself abstract by having an attribute __abstract set to True. The 'abstract' attribute can be used to find out if a class is abstract or not. ctj||||t}|D]5}t|ts|t|j j z}7tt|}||_|j||t||_ |jDcgc]\}}t|tr||f} }}| D]\} } |j| | |jD cgc] \}} t!| dr|| | j"f"} }} g}| D]e\}}}|j%dd}|j%dd}t'|d||}t)|d\}}|sM|j+||d k(|||fgg}t-|dd ddd D]}t!|d s|j.j0dD]\t3|d d}t3|dddi}t5fd ||zDr:|j%dsL|j+^d||zi|j._t6r|j9yycc}}wcc} }w)a Initialize the class object (not an instance of the class, but the class itself). Initializes all the Parameters by looking up appropriate default values (see __param_inheritance()) and setting attrib_names (see _set_names()). rrWrFrNra)rYrr_param__parametersrc34K|]}d|dk(yw)rNr^)rcr!rjs r7rez2ParameterizedMetaclass.__init__.. s F4EqCFadN4Es)r}rrr>rrr _ClassPrivater{!_ParameterizedMetaclass__set_namerrrlrXrYrrZrWr3rrWrSrr?rrhrkdocstring_signature(_ParameterizedMetaclass__class_docstring)rrKrrrrrrrrrr r?rQ dependersrrrrrrXr[r\ _inheritedrrjs @r7rzParameterizedMetaclass.__init__} sg c4.5D$ . C(<(<(M(M$NN (>N9OP- tU#!+C,1;;=3=!Q#Ay1!f= 3!+ Ju  % %j% 8!+5:KKM.M&1a8,AHH%M .#, D&%IIgu-Eii 51Gc4!')E!4UE!J D, tUh%6|TU$- S>#2&tt,C3 45yy))'2 c!fd37E2BCFF:4EFF '*%%c* 3-&z&'89    ! ! # G3.s /I!?%I'c|jdd}|ct|turtd|dt|d|jr#|j|_d|j _y||_yt|ddd}d}|D])}t|d s|j js'd}n|s||_yy) a Give Parameterized classes a useful 'name' attribute that is by default the class name, unless a class in the hierarchy has defined a `name` String Parameter with a defined `default` value, in which case that value is used to set the class name. rKNzParameterized class z0 cannot override the 'name' Parameter with type z>. Overriding 'name' is only allowed with a 'String' Parameter.TrFr) r3r}rHrrrKrrenamedrrZ)rrKr name_paramclasses found_renamedrs r7 __set_namez!ParameterizedMetaclass.__set_name sYYvt,  !Jv-*4(366::6F5GHSS !!%--.2##+nTrT*G!M1/0Q5F5F5N5N$(M!!rPctrtsy|jr |jnd}t|}|dz|z|_y)z Customize the class docstring with a Parameter table if `docstring_describe_params` and the `param_pager` is available. Nr? )docstring_describe_params param_pagerr)r class_docstr descriptions r7__class_docstringz(ParameterizedMetaclass.__class_docstring s8 ) &)kks{{r !#& "T)K7 rPcJ|j||j||yrb)r8*_ParameterizedMetaclass__param_inheritance)rr r?s r7rz,ParameterizedMetaclass._initialize_parameter s" $  E2rPcr t|d|jjdzS#t$rYywxYw)a Return True if the class has an attribute __abstract set to True. Subclasses will return False unless they themselves have __abstract set to true. This mechanism allows a class to declare itself to be abstract (e.g. to avoid it being offered as an option in a GUI), without the "abstract" property being inherited by its subclasses (at least one of which is presumably not abstract). z _%s__abstractrgF)rhrlstriprrs r7 __is_abstractz$ParameterizedMetaclass.__is_abstract s:  3s||/B/B3/GGH H  s '* 66c |jjr|jjStj|jtk7ryt g}}t |jD]}g}t|jjD]J\}}t|ts||vs|jr)|j||j|L|j|t |Dcgc] }|D]}| } }}tj | Dcgc]0}tj|tjj"2c}x|j_} | Scc}}wcc}w)aK For classes with a constructor signature that matches the default Parameterized.__init__ signature (i.e. ``__init__(self, **params)``) this method will generate a new signature that expands the parameters. If the signature differs from the default the custom signature is returned. N)rrrrrrreversedrrrrlrXrYrrSaddrr) r processed_kwskeyword_groupsr keyword_grouprzrxgrprrrs r7__get_signaturez&ParameterizedMetaclass.__get_signaturesY    ( (&&00 0   S\\ *.? ?(+r~ CGGI&CMs||11341a+0Fqzz!((+!%%a(5  ! !- 0 '#+>":I":3SrBSB":I4;4E4EG    a!2!2!?!? @G 5  %  JG s F55F c|jSrb)rrs r7 _get_paramz!ParameterizedMetaclass._get_param$s%%%rPct|j|\}}|rht|tsX||k7r3tj|}||_t j ||||j|jd|yt j |||t|tr|j||yy)a_ Implements 'self.attribute_name=value' in a way that also supports Parameters. If there is already a descriptor named attribute_name, and that descriptor is a Parameter, and the new value is *not* a Parameter, then call that Parameter's __set__ method with the specified value. In all other cases set the attribute normally (i.e. overwrite the descriptor). If the new value is a Parameter, once it has been set we make sure that the value is inherited from Parameterized superclasses as described in __param_inheritance(). N) rrXrYrrir}rrr!r)rattribute_namerr owning_classs r7rz"ParameterizedMetaclass.__setattr__)s "%!9!9.!I , Zi8s" IIi0 "%   ^I> LL ( 0 0e <   S 6% *''u=+rPc Dt|}tj|j}t |d||d=d|vrt |d||d=t |ddd}d}|D]]}|j j|}t|ts/|jdurd|_ t|} t| |r\d}_|d=ii} } d} |jD]N} |D]}|j j|}| t|| s-t|| }| j| t}|turX||ur]|tur || | <| s|son| |j vrd} n| j| ttur' |j"| }t'|r|| | <|| | <| d k(s|j(j*}|j,dur|j/|j0|j,dus$|j0|vs4|j3|j0Q| j5D]P\} }t || || d k7st|| }t7|s1t || t9j8|R| j5D]\} }t || |||j;|s| r*|j< |j?|j<yyy#t$$r}t%d| d |d |d}~wwxYw#t@$rv}tC|d }djEd|jFddD}|s | r |d|dz }n|r| s|d|jHd|dz }n |d|z }tK||d}~wwxYw)a Look for Parameter values in superclasses of this Parameterized class. Ordinarily, when a Python object is instantiated, attributes not given values in the constructor will inherit the value given in the object's class, or in its superclasses. For Parameters owned by Parameterized classes, we have implemented an additional level of default lookup, should this ordinary lookup return only `Undefined`. In such a case, i.e. when no non-`Undefined` value was found for a Parameter by the usual inheritance mechanisms, we explicitly look for Parameters with the same name in superclasses of this Parameterized class, and use the first such value that we find. The goal is to be able to set the default value (or other slots) of a Parameter within a Parameterized class, just as we can set values for non-Parameter objects in Parameterized classes, and have the values inherited through the Parameterized hierarchy as usual. Note that instantiate is handled differently: if there is a parameter with the same name in one of the superclasses with instantiate set to True, this parameter will inherit instantiate=True. rirNrFTrrz of parameter rrrz9 failed to validate its default value on class creation. rc34K|]}|jywrbr)rcklasss r7rez=ParameterizedMetaclass.__param_inheritance..s#R@QuENN@QrrzpThe Parameter is defined with attributes which when combined with attributes inherited from its parent classes (z7) make it invalid. Please fix the Parameter attributes.z)The Parameter type changed between class z and one of its parent classes (z7) which made it invalid. Please fix the Parameter type.z Validation failed with: )&r}r~rrrrrr3rXrYrr>rrZrhrlrCrrrrrrrSrKr|rlrrrrr'rr"rrrr)rr r?p_typeslotssupers type_change superclass super_param super_type callables slot_valuesslot_overriddenrscls new_param new_value old_value default_valrprrrxrbrparentss r7__param_inheritancez*ParameterizedMetaclass.__param_inheritanceHs>e f001 w$ 'N   E9c *i 3"%   J$--11*=Kk95&&$.$(!k*Jj&1" ! - !#R; JJLD !MM--j9 $GIt,D#It4 'OOD)<  ))+)+(1K%'+5#=#==*.-0tY/9<"'"6"6t">f/P rPr  rc |g}t|||||||}tt|}|rdj|dznd} | |zS)aV Variant of pprint() designed for generating a (nearly) runnable script. The output of script_repr(parameterized_obj) is meant to be a string suitable for running using `python file.py`. Not every object is guaranteed to have a runnable script_repr representation, but it is meant to be a good starting point for generating a Python script that (after minor edits) can be evaluated to get a newly initialized object similar to the one provided. The new object will only have the same parameter state, not the same internal (attribute) state; the script_repr captures only the state of the Parameters of that object and not any other attributes it may have. If show_imports is True (default), includes import statements for each of the modules required for the objects being instantiated. This list may not be complete, as it typically includes only the imports needed for the Parameterized object itself, not for values that may have been supplied to Parameters. Apart from show_imports, accepts the same arguments as pprint(), so see pprint() for explanations of the arguments accepted. The default values of each of these arguments differ from pprint() in ways that are more suitable for saving as a separate script than for e.g. pretty-printing at the Python prompt. rz r?)rr{rr) rrrrrrr show_importsrep imports_strs r7 script_reprr sY> gvx) %C3w< G3?499W%.RK  rPrr?c|g}t|trt||||}|St|tvrtt|||||}|St|trd}|St|t s!t|tur5t |t r%|jj||dz|||}|St|}|S)a Pretty printed representation of a parameterized object that may be evaluated with eval. Similar to repr except introspection of the constructor (__init__) ensures a valid and succinct representation is generated. Only parameters are represented (whether specified as standard, positional, or keyword arguments). Parameters specified as positional arguments are always shown, followed by modified parameters specified as keyword arguments, sorted by precedence. unknown_value determines what to do where a representation cannot be generated for something required to recreate the object. Such things include non-parameter positional and keyword arguments, and certain values of parameters (e.g. some random state objects). Supplying an unknown_value of None causes unrepresentable things to be silently ignored. If unknown_value is a string, that string will appear in place of any unrepresentable things. If unknown_value is False, an Exception will be raised if an unrepresentable value is encountered. If supplied, imports should be a list, and it will be populated with the set of imports required for the object and all of its parameter values. If qualify is True, the class's path will be included (e.g. "a.b.C()"), otherwise only the class will appear ("C()"). Parameters will be separated by a comma only by default, but the separator parameter allows an additional separator to be supplied (e.g. a newline could be supplied to have each Parameter appear on a separate line). Instances of types that require special handling can use the script_repr_reg dictionary. Using the type as a key, add a function that returns a suitable representation of instances of that type, and adds the required import statement. The repr of a parameter can be suppressed by returning None from the appropriate hook in script_repr_reg. Nz )rrrrr) rXr}type_script_reprscript_repr_reg_no_script_reprrr>r?rr)rrrrrrrrs r7rr4sX#ds76(; J co %d3i(WVHE J C ) J C 'DI,=*SR_B` II  WVF] '}"+  - J I JrPc g}|D]}|jt||||!t|trd\}}nt|trd\}}nt |dj |z|z}|S)N)[])rrr)rSrrXr{r|rr) containerrrrrrCd1d2rs r7container_script_reprr{su F  fQwvh78)D!2 Ie $2!! 388F BC JrPc#Ktjjdx}r|jtjjdx}r|jyyw)Nrandomz numpy.random)r1r2r3Random RandomState)rnprs r7r r sQ**v*mmkkoon--s-oo.sA!A#cj|j}|j}|jd|z|dz|zS)NrrA)rrrS)rbrrrrKmodules r7function_script_reprrs3 ;;D ]]F NN;v%& #:d?rPcp|j}|dk7r|jd|z|dz|jzS)N __builtin__rrA)rrSr)type_rrrrs r7r r s9   F }{6)* #:enn $$rPcht||dz kDr |d|dz dzn|}tj|S)z2Return HTML-safe truncated version of given stringr+Nz..)r=htmlr )str_maxlenrs r7truncater$s7),TfQh)?4 &( t #dC ;;s rPc zt|ts!t|tur-t|tr|jj d}n2t |dr|j }ntt||}t |dr|jd}nQt |drY|j\}}|j\} } |dn| rdndt|z} |dn| rd nd t|z} | | r|rd ndz| z}nt|j}nt |d r?|jr3d jttt|j}nt |d rTt|j t"r#djd|j D}nB|j j$}n+t |dr|j&d|j&d}nd}|j(rdjdd|fD}n&|j*rdjdd|fD}t-|ddrdjdd|fD}|j.r'dt1|j.j3dnd} d| d|d|d|j4j$d |d! S)"z?HTML representation for a single Parameter object and its valueF)rrboundsr?inclusive_boundsz>=>z<=.sA rrIzregex(rrc3&K|] }|s| ywrbr^rcrs r7rez"_get_param_repr..sG%AQ!%Azread-onlyc3&K|] }|s| ywrbr^r,s r7rez"_get_param_repr..F%@A!%@r-zconstantrc3&K|] }|s| ywrbr^r,s r7rez"_get_param_repr..r/r-znullablez) class="param-doc-tooltip" data-tooltip=""z(

z$ z% z )rXrr}r>r?rrZr$rr&r'rrrr{maprr|rrIrrrhrr rLr)rrrvallendoclenrrange_blbuiliulbubtooltips r7_get_param_reprr=sd#}%$s)t*; 3P]@^ %%5%1 m $!cF+q( 88 F Q) *HHEBr&&EBrzs2w'FBzs2w'FB2"4"5:F!((^F I 1994D!)) 456 H  ahh &ZZAAAFXX&&F G !4!''!$zzG&8&%AGG F&7%@FFq,&F&7%@FFVWV[V[9&:O9PPQRacG //6iq><*>)?@++1(3  rPc 8ttrj}|jdz}d}n}|j}d}d}|rdnd}jj j }djfd|D}d|d |d |d |d |d S)z.HTML representation for a Parameterized object()ValueDefaulta .param-doc-tooltip{ position: relative; cursor: help; } .param-doc-tooltip:hover:after{ content: attr(data-tooltip); background-color: black; color: #fff; border-radius: 3px; padding: 10px; position: absolute; z-index: 1; top: -5px; left: 100%; margin-left: 10px; min-width: 250px; } .param-doc-tooltip:hover:before { content: ""; position: absolute; top: 50%; left: 100%; margin-top: -5px; border-width: 5px; border-style: solid; border-color: transparent black transparent transparent; } z openr?c3XK|]!\}}t||j|#ywrb)r=r?)rcrrrs r7rez+_parameterized_repr_html..s.5'383'sC>'3s'*z

z
z
Namez?TypeRange
)rXrrrKr?rrlr) rrrtitle value_field tooltip_cssopenstrr'contentss ` r7rrs!]#kk4  K:g2G77>>#))+Lww5'355H +9UVaTabb *, , rPc6eZdZdZgdZ ddZdZdZy)ra# parameters_state: dict Dict holding some transient states disable_instance_params: bool Whether to disable instance parameters renamed: bool Whethe the class has been renamed by a super class params: dict Dict of parameter_name:parameter rrrrrrrNc|ddggd}||_||_||_|in||_d|_d|_|g|_y||_yNF)rrrrrI)rrrrrrs r7rz_ClassPrivate.__init__>sh  #$     !1'>$ "Nb  &6&>DTrPcV|jDcic]}|t||c}Scc}wrbrrhr:s r7r;z_ClassPrivate.__getstate__U*6:nnEndgdD))nEEE&cN|jD]\}}t|||yrbr=r>s r7r@z_ClassPrivate.__setstate__X"KKMDAq D!Q "rP)NFNFNrrrrrrr;r@r^rPr7rr(s0 I % U.F rPrc<eZdZdZgdZ ddZdZdZy)r(as initialized: bool Flag that can be tested to see if e.g. constant Parameters can still be set parameters_state: dict Dict holding some transient states dynamic_watchers: defaultdict Dynamic watchers ref_watchers: list[Watcher] Watchers used for internal references params: dict Dict of parameter_name:parameter refs: dict Dict of parameter name:reference watchers: dict Dict of dict: parameter_name: parameter_attribute (e.g. 'value'): list of `Watcher`s values: dict Dict of parameter name: value ) rrrrr%rrrrrrNc ||_|gn||_t|_|ddggd}g|_i|_||_|ttn||_ |in||_ |in||_ |in||_ |i|_ y||_ yrK)rrrrrr%rrr{rrrrr) rrrrrrrrrs r7rz_InstancePrivate.__init__s'&6&>DTu  #$      05E5M D 1Sc"Nb ,BD &.H "Nb  rPcV|jDcic]}|t||c}Scc}wrbrMr:s r7r;z_InstancePrivate.__getstate__rNrOcN|jD]\}}t|||yrbr=r>s r7r@z_InstancePrivate.__setstate__rQrP)FNNNNNNNrRr^rPr7r(r(]s8* I  7<F rPr(cheZdZdZedddZdZedZdZ d Z e d Z d Z y) ra Base class for named objects that support Parameters and message formatting. Automatic object naming: Every Parameterized instance has a name parameter. If the user doesn't designate a name= argument when constructing the object, the object will be given a name consisting of its class name followed by a unique 5-digit number. Automatic parameter setting: The Parameterized __init__ method will automatically read the list of keyword parameters. If any keyword matches the name of a Parameter (see Parameter class) defined in the object's class or any of its superclasses, that parameter in the instance will get the value given as a keyword argument. For example: >>> class Foo(Parameterized): ... xx = Parameter(default=1) >>> foo = Foo(xx=20) in this case foo.xx gets the value 20. When initializing a Parameterized instance ('foo' in the example above), the values of parameters can be supplied as keyword arguments to the constructor (using parametername=parametervalue); these values will override the class default values for this one instance. If no 'name' parameter is supplied, self.name defaults to the object's class name with a unique number appended to it. Message formatting: Each Parameterized instance has several methods for optionally printing output. This functionality is based on the standard Python 'logging' module; using the methods provided here, wraps calls to the 'logging' module's root logger and prepends each message with information about the instance from which the call was made. For more information on how to set the global logging level and change the default message prefix, see documentation for the 'logging' module. NTz+ String identifier for this object.)rrrc 8t|jts.tt|jj|_|j j j|jjk(r|j j|j jdi|\}}tdz a d|j_ |j j||j jd||j_y)NrrT)rr^)rXrr(r}rr?rKrrrrrrrrr*r)rrrr[s r7rzParameterized.__init__s$..0@A#3!%d!;!;!L!L$D ::?? " "dnn&=&= = JJ % % '-TZZ--77 d +/( t$ T*$(!rPc0t|j|S)a> The `.param` namespace for `Parameterized` classes and instances. This namespace provides access to powerful methods and properties for managing parameters in a `Parameterized` object. It includes utilities for adding parameters, updating parameters, debugging, serialization, logging, and more. User Guide ---------- For more details on parameter objects and instances, see: https://param.holoviz.org/user_guide/Parameters.html#parameter-objects-and-instances Examples -------- Basic usage of `.param` in a `Parameterized` class: >>> import param >>> >>> class MyClass(param.Parameterized): ... value = param.Parameter() >>> >>> my_instance = MyClass(value=0) Access the `value` parameter of `my_instance`: >>> my_instance.param.value # the Parameter instance Note that this is different from the current `value` of `my_instance`: >>> my_instance.value # the current parameter value 0 r)rrrs r7r?zParameterized.paramsF$..t44rPcx|jj}t|D]}t||||<|S)z Save the object's state: return a dictionary that is a shallow copy of the object's __dict__ and that also includes the object's __slots__ (if it has any). )rrrrh)rr?rs r7r;zParameterized.__getstate__s< ""$&t,D!$t,E$K- rPc2t|jj}t||_d|j_|j dd}| t|}|j r|j }|jD]\}}|jD]\}}g} |D]} t| } | j|| d<| j} t| drt|| j| d<n0t| | jurt|| j | d<| j#t%| | |||<|j'dd|jD]\} }t)|| |d |j_y) z Restore objects from the state dictionary to this object. During this process the object is considered uninitialized. rFrNrrr+r?T)r}rrr(rr3rrlr{rTrbrZrrrrhrrSrrr)rr?rrparam_watchersrrrr new_watchersr  watcher_argsrbrKrs r7r@zParameterized.__setstate__)st  :55FF/AQR+0())$5t<  ".@PQO  # #,55N*0025&+kkmND(#%L#+'+G} "<<3.2LO$ZZ"27.7b>N>N.OLO-b1W\\A.5dBKK.HLO$++G\,BC$,/;N1%d+'43  '4 ++-JD De $(+/(rPc  |jjjDcgc] \}}|d|}}}|jj dzdj |zdzScc}}w#t$rg}YAwxYw)a Provide a nearly valid Python representation that could be used to recreate the item with its parameters, if executed in the appropriate environment. Returns 'classname(parameter1=x,parameter2=y,...)', listing all the parameters of this object. rrrr)r?rrlrrrr)rrKrrs r7rzParameterized.__repr__Ps )-):):)<)B)B)DF)DID# &#))D F~~&&,tyy/BBSHH F H s!+A5A/A5/A55 BBcPd|jjd|jdS)zCReturn a short representation of the name and class of this object.r)rr()rrrKrs r7rzParameterized.__str__`s&4>>**+1TYYKq99rP)rrrrrHrKrrr?r;r@r rrr^rPr7rrs`(T $4. /D)2"5"5L(%0N I I:rPrctdtdtdtdtt}|jd|D]}|j tdy)z5Print the default values for all imported Parameters.O_______________________________________________________________________________r?z3 Parameter Default Valuesc|jSrbr)xs r7r"z*print_all_param_defaults..lsajjrPrN)rr%rrSr)rrs r7print_all_param_defaultsreesZ [\ "I ?@ "I-(G LL(L)    [\rPcVeZdZdZddZdZdZdZdZdZ dZ dd Z d Z d Z d Zy )ParamOverridesz A dictionary that returns the attribute of a specified object if that attribute is not present in itself. Used to override the parameters of an object. c||_tj|||r|j||_y|j |y)a If allow_extra_keywords is False, then all keys in the supplied dict_ must match parameter names on the overridden object (otherwise a warning will be printed). If allow_extra_keywords is True, then any items in the supplied dict_ that are not also parameters of the overridden object will be available via the extra_keywords() method. N) _overriddenr~r_extract_extra_keywords_extra_keywords _check_params)r overriddenrallow_extra_keywordss r7rzParamOverrides.__init__s> & d5! !%!=!=e!DD   u %rPc|jS)z Return a dictionary containing items from the originally supplied `dict_` whose names are not parameters of the overridden object. )rkrs r7extra_keywordszParamOverrides.extra_keywordss ###rPcZ|Dcic]}||jvs|||c}Scc}w)z Return a dictionary containing items from the originally supplied `dict_` whose names are parameters of the overridden object (i.e. not extra keywords/parameters). )rprrs r7param_keywordszParamOverrides.param_keywordss4 +/S$3#T=P=P=R2RT#Y$SSSs((c.t|j|Srb)rhrirs r7 __missing__zParamOverrides.__missing__st''--rPc^tj|dt|jzzS)Nz overriding params from %s)r~rrrirs r7rzParamOverrides.__repr__s'}}T"#?TEUEU@V#VVVrPc$|j|Srb)rrs r7rzParamOverrides.__getattr__s%%rPcz|jds|j||ytj|||y)Nrg)r __setitem__r~r)rrKrs r7rzParamOverrides.__setattr__s2s#   T# &   T$s +rPNc0 ||S#t$r|cYSwxYwrb)r)rrrs r7r3zParamOverrides.gets% 9  N s  cR||jvxs||jjvSrb)rrir?rrs r7rzParamOverrides.__contains__s'dmm#Dsd.>.>.D.D'DDrPct|jj}|D]#}||vs|jjd|%y)zx Print a warning if params contains something that is not a Parameter of the overridden object. z''%s' will be ignored (not a Parameter).N)r{rir?r})rroverridden_object_paramsitems r7rlzParamOverrides._check_paramssC $((8(8(>(>#? D33 ""#LTRrPci}t|jj}|jD]\}}||vs |||<|S)zk Return any items in params that are not also parameters of the overridden object. )r{rir?rl)rrrpr}rKrs r7rjz&ParamOverrides._extract_extra_keywordssO #'(8(8(>(>#? ID#33%(t$( rPrrb)rrrrrrprsrurrrr3rrlrjr^rPr7rgrgwsB&0$T.W& , ES rPrgc,tj|Srb)rrrs r7_new_parameterizedrs   %%rPcHeZdZdZdZdZedZdZdZ dZ d d Z y) ParameterizedFunctiona@ Acts like a Python function, but with arguments that are Parameters. Implemented as a subclass of Parameterized that, when instantiated, automatically invokes __call__ and returns the result, instead of returning an instance of the class. To obtain an instance of this class, call instance(). Tc4|jjdzS)Nr?)rrrs r7rzParameterizedFunction.__str__s~~&&t++rPc Xt|tr|}nJ|}|jj}|j ||j d|j }tj|}tj|fi|d|vr |d|_ |S|j|_ |S)zs Return an instance of this class, copying parameters from any existing instance provided. rK) rXr r?rrArrrrrrrK)rrrrrTs r7rzParameterizedFunction.instances {#9 :CA &&--/F MM!  JJv ''C  " "3 't-f- V fVndm /:.>.>dm rPc|j}|jj|j|j|i|Srb)rr?rr__call__)rrnrrTs r7rzParameterizedFunction.__new__s:  V__-t}}d,V,,rPctd)Nz#Subclasses must implement __call__.)r)rrnr`s r7rzParameterizedFunction.__call__s!"GHHrPcTtj|}t|jf|fSrb)rr;rr)rr?s r7 __reduce__z ParameterizedFunction.__reduce__s*&2248 #DNN#4U;;rPNc|jj|||||}|jj}|j d|zd|zS)zv Same as self.param.pprint, except that X.classname(Y is replaced with X.classname.instance(Y )rrrz.%s(z .%s.instance()r?rrrr)rrrrrrrrs r7rzParameterizedFunction._pprint!sV JJ  gf,9&-   C..)) yy )/)*CDDrP)NrrFr?) rrrr _ParameterizedFunction__abstractrrrrrrrr^rPr7rrsGJ,(- I<CH)+ ErPrcReZdZdZeddZeddZeidZdZy) default_label_formatterzIDefault formatter to turn parameter names into appropriate widget labels.Tz8 Whether or not the label should be capitalized.)rrzC Whether or not underscores should be replaced with spaces.z Allows custom labels to be specified for specific parameter names using a dictionary where key is the parameter name and the value is the desired label.c||jvr|j|S|jr|jdd}|jr|ddj |ddz}|S)Nrgrr) overridesreplace_underscoresr capitalizer)rrs r7rz default_label_formatter.__call__<s_ DNN ">>%( (  # #MM#c*E ??"1IOO%ab 1E rPN) rrrrrYrrrrr^rPr7rr.sDS4.;)rrrrh)rrrs r7r zoverridable_property.__get__fsj ;K 99  !78 8 99   +4993E3E99S> !373 2 235 5rPc|j td|jjdk(s|jjs|j||yt||jj|y)Nzcan't set attributer)rrrrh)rrrs r7r!zoverridable_property.__set__ps_ 99  !67 7 99   +4993E3E IIc5 ! ,GC++ ,U 3rPc|j td|jjdk(s|jjs|j|yt||jjy)Nzcan't delete attributer)rrrrhr3s r7r4zoverridable_property.__delete__xsZ 99  !9: : 99   +4993E3E IIcN ,GC++ , .rP)NNNNrb)rrrrrr r!r4r^rPr7rrNs 64/rPrrbrrr)z...)rNN))r()rrrr/r.r!rrCrzr|rMr1rrDr1r collectionsrrr functoolsrrr r itertoolsr r r rr contextlibrrrrrrr?r_utilsrrr3rrrrrrr r!r"r#r$r%r&ipythonr'r(r*rModuleNotFoundErrorr8r<r= addLevelNamerBrOrrrrrrRrUr\rsrwrrrrlrrrrrrrrrrrrrr rrrr%rr4rBrRrWrirqrsr~rrrrVrrr_Watcherrr}rrrYrHrQrdrnrrr rr rr rr rr r{r|rr$r=rrr(rrer~rgrrrrrr^rPr7rs   "<<,,+*%99*=+Q 40 'K      (Wi( @(    3 %"0 D   L --$ 7 7" ;I\]^ 77$44   --"(  ' ,-.4 ,- .  88*5   $$  0TTn.&:4.4'.tdUY 'td  756    723    7F# 7<= * i!f g-*h-*d&3&3RA$1A$HR  R  l6.Y6.r--*#&FFR$`m`mF3WTW@ #"(RDD(XHr?F&   % .. 4  3l7z2 2 jG G T{:4{:| ]$jTj\&BEMBEJ30*0/0/_P +**+s1M MM