h)Q  SrSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK J r SSKJr SSKJrJrJrJr SSKJr SS KJr SS KJr SS KJrJrJr \\ \!\"4r#\$4r%\ RL(aSS K'J(r( OSS K J(r( /S Qr)\"SSS5r*\"SSS5r+\*r,"SS\-5r.SSjr/SSjr0SSjr1SSjr2"SS5r3SSSjjr4SSjr5"SS5r6"SS 5r7\7r8"S!S"5r9\("S#5r:\("S$5r;\("S%5r<\ RL(a SS&K'J=r=J>r> \("S'\?S(9r@\("S)\ RS(9rB"S*S+\9\ R\:\;45rD"S,S-5rESS.jrF"S/S0\$5rG"S1S2\G5rHS3S4.SS6jjrISS8jrJSS:jrKSS<jrL\ RP"S7\ RS=\ R4S>9rN"S?S@\95rO"SAS5\O5rP"SBS9\O5rQ"SCS;\O5rR"SDSE\GSF9rS"SGSH\S\HSF9rT"SISJ\D\:\;45rU"SKSL\U\:\;45rV"SMSN\U\<\<45rW"SOSP5rX"SQSR\X\V\:\;45rY"SSST\X\W\<5rZ"SUSV\U\ R\<\ R\<45r\"SWSX\D\ R\ R45r]"SYSZ\D\ R\ R\ R\ R45rASS[jr^"S\S]\D\:\;45r_"S^S_\_\:\;45r`\_\`srarb\_rc"S`Sa\D\:\;45rd"SbSc\d\:\;45re"SdSe\D\f\ R\f\g\h445ri"SfSg\i\D\f\ R45rj"ShSi\D\k\k45rl"SjSk\l\D\k\ R45rm"SlSm\D\:\;45rn"SnSo\n\:\;4\D\?\ R45ro"SpSq\D\?\?45rp"SrSs\p5rq"StSu\D\:\;45rr"SvSw\r\:\;45rs"SxSy\D\:\:45rt"SzS{\t\:5ru"S|S}\t\:5rv"S~S\W\<5rw"SS\w\ R\<5rx"SS\w\ R\ R5ry"SS\w\ R\ RS=45rz"SS\WS5r{"SS\D\:\;45r|"SS\DS\ RS\?445r}"SS\D\ R\ R45r~"SS\D\ RS=\ R4\ RS=\ R445rMg)a A lightweight Traits like module. This is designed to provide a lightweight, simple, pure Python version of many of the capabilities of enthought.traits. This includes: * Validation * Type specification with defaults * Static and dynamic notification * Basic predefined types * An API that is similar to enthought.traits We don't support: * Delegation * Automatic GUI generation * A full set of trait types. Most importantly, we don't provide container traits (list, dict, tuple) that can trigger notifications if their contents change. * API compatibility with enthought.traits There are also some important difference in our design: * enthought.traits does not validate default values. We do. We choose to create this module because we need these capabilities, but we need them to be pure Python so they work in all Python implementations, including Jython and IronPython. Inheritance diagram: .. inheritance-diagram:: traitlets.traitlets :parts: 3 ) annotationsN) literal_eval)Bunch) add_articleclass_ofdescribe repr_type) getargspec import_item)Sentinel)deprecated_method should_warnwarn)TypeVar);AllAnyBaseDescriptorBoolBytesCBoolCBytesCComplexCFloatCIntCLongCRegExpCUnicodeCallableCaselessStrEnumClassBasedTraitTypeComplex ContainerDefaultHandlerDictDottedObjectNameEnum EventHandlerFloatForwardDeclaredInstanceForwardDeclaredMixinForwardDeclaredType FuzzyEnumHasDescriptors HasTraitsInstanceIntIntegerListLongMetaHasDescriptors MetaHasTraits ObjectNameObserveHandlerSet TCPAddressThis TraitError TraitTypeTupleTypeUnicode UndefinedUnionUseEnumValidateHandlerdefaultdirectional_linkdlinklinkobserveobserve_compatparse_notifier_namevalidaterB traitletszA Used in Traitlets to specify that no defaults are set in kwargs rzi Used in Traitlets to listen to all types of notification or to notifications from all trait attributes. c\rSrSrSrg)r=N)__name__ __module__ __qualname____firstlineno____static_attributes__rQfC:\Users\julio\OneDrive\Documentos\Trabajo\Ideas Frescas\venv\Lib\site-packages\traitlets/traitlets.pyr=r=srWr=cT[R"[UR55$N)tcastbool isidentifierss rXr^r^s 66$( ))rWcT[U5$![[[4a Us$f=f)zkSafely evaluate an expression Returns original string if eval fails. Use only where types are ambiguous. )r NameError SyntaxError ValueErrorr_s rX_safe_literal_evalres,A {J /s ''c~[U[5=(d' [U[5=(a [U[5$)zHReturns whether the given value is an instance or subclass of TraitType.) isinstancer>type issubclass)r[s rXis_traitrjs' a # Y 1d(;(X 1i@XYrWc@U[Ld[U[5(aU/$[U[5(a [ S5eU(a [U;a[/$UH>n[U[5(aM[ S[ U5R SU<S35e U$)zConvert the name argument to a list of names. Examples -------- >>> parse_notifier_name([]) [traitlets.All] >>> parse_notifier_name("a") ['a'] >>> parse_notifier_name(["a", "b"]) ['a', 'b'] >>> parse_notifier_name(All) [traitlets.All] z7`names` must be either `All`, a str, or a list of strs.znames must be strings, not ())rrgstrr TypeErrorrhrR)namesns rXrLrLs |z%--w E8 $ $QRRu 5LAa%%"=d1g>N>N=OqQRPUUV WXX rWc<\rSrSrSSjrS SjrS SjrS SjrSrg) _SimpleTestcXlgrZvalueselfrws rX__init___SimpleTest.__init__s rWc0[XR:H5$rZ)r]rw)rytests rX__call___SimpleTest.__call__sDJJ&''rWc SUR-$)NzBC CrWcz\rSrSrSrSrS S SjjrSSjr\RSSj5r SSjr SS jr SS jr S rg)rIi a Link traits from different objects together so they remain in sync. Parameters ---------- source : (object / attribute name) pair target : (object / attribute name) pair transform: iterable with two callables (optional) Data transformation between source and target and target and source. Examples -------- >>> class X(HasTraits): ... value = Int() >>> src = X(value=1) >>> tgt = X(value=42) >>> c = link((src, "value"), (tgt, "value")) Setting source updates target objects: >>> src.value = 5 >>> tgt.value 5 FNc[X5 XsUlUlU(aUOS4S-uUlUlUR 5 g)NcU$rZrQxs rXlink.__init__..+sVWrWr)rsourcetarget _transform_transform_invrIryrr transforms rXrz link.__init__(s<v&#)  T[\]K],, rWc d[URSURSUR[URSURS555 URSR UR URSS9 URSR URURSS9 g!URSR UR URSS9 URSR URURSS9 f=fNrrrp)setattrrrrrrJ_update_target_update_sourcers rXrI link.link/s N  A A A A GH  KKN " "4#6#6dkk!n " M KKN " "4#6#6dkk!n " M KKN " "4#6#6dkk!n " M KKN " "4#6#6dkk!n " Ms ACA*D/c#J# SUlSv SUlg!SUlf=f7fNTFupdatingrs rX_busy_updatinglink._busy_updating;"  " !DMEDM## #cUR(agUR5 [URSURSUR UR 55 [ URSURS5UR :wa[SUS35eSSS5 g!,(df  g=f)Nrr Broken link z5: the source value changed while updating the target.) rrrrrnewrrr=rychanges rXrlink._update_targetCs ==   " DKKNDKKNDOOFJJ4O Pt{{1~t{{1~6&**D "4&(aaE# " " BB11 B?cUR(agUR5 [URSURSUR UR 55 [ URSURS5UR :wa[SUS35eSSS5 g!,(df  g=f)Nrrrz5: the target value changed while updating the source.) rrrrrrrrr=rs rXrlink._update_sourceMs ==   " DKKNDKKND4G4G 4S Tt{{1~t{{1~6&**D "4&(aaE# " "rcURSRURURSS9 URSRURURSS9 gr)r unobserverrrrs rXunlink link.unlinkWsT A  !4!4DKKN K A  !4!4DKKN KrW)rrrrrrZrrrrrrrrrrrrrrrr)rRrSrTrU__doc__rrzrI contextlibcontextmanagerrrrrrVrQrWrXrIrI sC0H N""LrWrIcp\rSrSrSrSrS S SjjrS Sjr\RSSj5r SSjr S S jr S r g)rGi\a:Link the trait of a source object with traits of target objects. Parameters ---------- source : (object, attribute name) pair target : (object, attribute name) pair transform: callable (optional) Data transformation between source and target. Examples -------- >>> class X(HasTraits): ... value = Int() >>> src = X(value=1) >>> tgt = X(value=42) >>> c = directional_link((src, "value"), (tgt, "value")) Setting source updates target objects: >>> src.value = 5 >>> tgt.value 5 Setting target does not update source object: >>> tgt.value = 6 >>> src.value 5 FNcxU(aUOSUl[X5 XsUlUlUR 5 g)NcU$rZrQrs rXr+directional_link.__init__..~srW)rrrrrIrs rXrzdirectional_link.__init__}s,'0)kv&#)  T[ rWc [URSURSUR[URSURS555 URSR UR URSS9 g!URSR UR URSS9 f=fr)rrrrrrJ_updaters rXrIdirectional_link.links G  A A A A GH  KKN " "4<iz!A base class for all trait types.dict[str, t.Any]metadataFr] allow_none read_only any valuern info_textr default_valueNc U[LaXlU(aX lUbX0lUbUOSUlUR(aURUl[ U5S:Ga/Sn[R"5nUceURRS:Xa2US- nURnUceURRS:XaM2URRS5=(d Sn U RSS5Sn SU /[U5Q7n [!U 5(a[#S US 3[$US 9 [ UR&5S:a;UR&R)5UlUR&R+U5 O&X`lOUR&R)5UlUbXPR&S 'UbX@R&S 'gg)a Declare a traitlet. If *allow_none* is True, None is a valid value in addition to any values that are normally valid. The default is up to the subclass. For most trait types, the default value for ``allow_none`` is False. If *read_only* is True, attempts to directly modify a trait attribute raises a TraitError. If *help* is a string, it documents the attribute's purpose. Extra metadata can be associated with the traitlet using the .tag() convenience method or by using the traitlet instance's .metadata dictionary. NrrrzrR.z metadata-tagz metadata z was set from the constructor. With traitlets 4.1, metadata should be set using the .tag() method, e.g., Int().tag(key1='value1', key2='value2') stacklevelconfighelp)rBrrrr rrinspect currentframef_codeco_namef_back f_globalsgetsplitsortedrrDeprecationWarningrcopyupdate) ryrrrr rkwargsrfmodpkgrs rXrzTraitType.__init__s,  )!.  (O  &N ,D" 9999DL v;?J$$&A= =((""j0a HH}$}((""j0++//*-3C))C#A&C!388C3x(DD') 4==!A% $ 2 2 4  $$V, &  MM..0DM  &,MM( #  $(MM& ! rWc6UR(aUS:XagU$)zGet a value from a config string such as an environment variable or CLI arguments. Traits can override this method to define their own parsing of config strings. .. seealso:: item_from_string .. versionadded:: 5.0 rNrryr`s rX from_stringTraitType.from_string?s ??qF{rWc0UR[La%[R"[UR5$[ US5(a)[R"[UR 55$[R"[UR5$)zThe default generator for this trait Notes ----- This method is registered to HasTraits classes during ``class_init`` in the same way that dynamic defaults defined by ``@default`` are. make_dynamic_default)rrBr[r\rhasattrr!rs rXrFTraitType.defaultOsj   Y .66!T//0 0 T1 2 266!T6689 966!T//0 0rWcj[S[SS9 [R"[UR 5$)z]DEPRECATED: Retrieve the static default value for this trait. Use self.default_value instead zRget_default_value is deprecated in traitlets 4.0: use the .default_value attributerr)rrr[r\rrrs rXget_default_valueTraitType.get_default_value_s. `  vva++,,rWc[S[SS9 URXR5nX!RUR 'U$)z  +**I +  F s#B B BB B/.B/cxUR(a[SUR-5eURX5 g)zSet the value of the trait by self.name for the instance. Values pass through a validation stage where errors are raised when impropper types, or types that cannot be coerced, are encountered. zThe "%s" trait is read-only.N)rr=rrBr*s rX__set__TraitType.__set__s, >>;diiGH H rWcUcUR(aU$[US5(aURX5nURSLaUR X5n[ R "[U5$)NrMF)rr"rMr1_cross_validater[r\rr*s rXr(TraitType._validates\ =T__L 4 $ $MM#-E  % % .((4EvvarWcxURUR;a.[XUS.5nURUR"X5nOX[USUR-5(a:SUR-n[ X5n[ UUR US5 U"X 5n[R"[U5$)N)traitrwr. _%s_validate use @validate decorator instead.) r_trait_validatorsrr"rr __class__r[r\r)ryrrwproposal meth_namecross_validates rXrHTraitType._cross_validates 99-- -tcJKH))$))4SCE S.4994 5 5&2I$S4N  2   #5/EvvarWct[U[5(a[U/URQ5$[X/5$rZrgrC trait_typesryothers rX__or__TraitType.__or__s5 eU # #$3!2!234 4$' 'rWcUR$rZ)rrs rXinfoTraitType.infos ~~rWc fUbU=RU4- slURbSRSURSS55nUbUSRUR[ SU5UURS[ SURS 554UlUeS RURUURS[ SURS 554UlUeURc#[ X$=(d UR 5U5eUbIS RUR[U5U=(d UR 5[ SU55nO>S RURU=(d UR 5[ SU55n[ U5e) aRaise a TraitError Parameters ---------- obj : HasTraits or None The instance which owns the trait. If not object is given, then an object agnostic error will be raised. value : any The value that caused the error. error : Exception (default: None) An error that was raised by a child trait. The arguments of this exception should be of the form ``(value, info, *traits)``. Where the ``value`` and ``info`` are the problem value, and string describing the expected value. The ``traits`` are a series of :class:`TraitType` instances that are "children" of this one (the first being the deepest). info : str (default: None) A description of the expected value. By default this is inferred from this trait's ``info`` method. N of c3:# UHn[SU5v M g7f)aN)r ).0r[s rX "TraitType.error..s#MnHS!$4$4nsrzDThe '{}' trait of {} instance contains {} which expected {}, not {}.anrtherz5The '{}' trait contains {} which expected {}, not {}.z2The '{}' trait of {} instance expected {}, not {}.z#The '{}' trait expected {}, not {}.)argsrjoinformatr r=r\r)ryrrwerrorr\chainr4s rXrjTraitType.errors~@   JJ4' !Jyy$ #Mejjn#MM?//5v II$T3/!!JJqM$UEJJqM: 0 "EJ&KSYY II!!JJqM$UEJJqM: "EJK 99 U$7DIIK> > ?DKK  # & A6<< # &A mrWcrUS:XaSnOSn[SU-[SS9 URRX5$)z^DEPRECATED: Get a metadata value. Use .metadata[key] or .metadata.get(key, default) instead. r z3use the instance .help string directly, like x.helpzduse the instance .metadata dictionary directly, like x.metadata[key] or x.metadata.get(key, default)Deprecated in traitlets 4.1, rr)rrrr)ryrrFmsgs rX get_metadataTraitType.get_metadataAs> &=GCxC ,s 24FSTU}}  ..rWcZUS:XaSnOSn[SU-[SS9 X RU'g)zKDEPRECATED: Set a metadata key/value. Use .metadata[key] = value instead. r z;use the instance .help string directly, like x.help = valuezLuse the instance .metadata dictionary directly, like x.metadata[key] = valuernrrN)rrr)ryrrwros rX set_metadataTraitType.set_metadataMs5 &=OC`C ,s 24FSTU" crWc [UR55R1Sk5nU(a[SU-[SS9 UR R U5 U$)zSets metadata and returns self. This allows convenient metadata tagging when initializing the trait, such as: Examples -------- >>> Int(0).tag(config=True, sync=True) >r rrrzcThe following attributes are set in using `tag`, but seem to be constructor keywords arguments: %s rr)rBkeys intersectionr UserWarningrr)ryrmaybe_constructor_keywordss rXtag TraitType.tagYsZ&)%9%F%F @& " & u,-   X& rWc,[UR5$rZ)reprrrs rXdefault_value_reprTraitType.default_value_reprrsD&&''rW)rrrr rr)ryzTraitType[G, S]rrrr]r bool | Noner rrrrrrr)r`rnrG | NonerZ)rrrr)rr)rr0rztype[t.Any] | Nonerr)rrr type[t.Any]rr)rrrrrr)rHasTraits | NonerrrzSelf | G)rr0rwrrr)rrrwrrr)rXzTraitType[t.Any, t.Any]rrCr)NN) rrrwrrjzException | Noner\rrz t.NoReturn)rrnrFrrr)rrnrwrrr)rrrr)!rRrSrTrUrrrrrrrBrrzrrFr%r+rr[overloadr8rBrEr(rHrYr\rjrprsrzr~rVrQrWrXr>r>si+!#H#JIt Is $M5$ ) !% B)B)B)B) B)  B)  B)B) B)H 1 - %$NZZ  ZZ   1?&  ( #' O OO O  O  Ob / #2(rWr>c6\rSrSrSrSSjrS SjrS SjrSrg) _CallbackWrapperi{zAn object adapting a on_trait_change callback into an observe callback. The comparison operator __eq__ is implemented to enable removal of wrapped callbacks. cXl[UR[R5(aSOSn[ [ U5S5U-UlUR S:a [S5eg)Nrz1a trait changed callback must have 0-4 arguments.)cbrgtypes MethodTyperr nargsr=)ryroffsets rXrz_CallbackWrapper.__init__sZ!$''5+;+;<<!B*+f4 ::>PQ Q rWc[U[5(a"[URUR:H5$[URU:H5$rZ)rgrr]rrWs rX__eq___CallbackWrapper.__eq__s< e- . .588+, ,5() )rWc*URS:XaUR5 gURS:XaURUR5 gURS:Xa'URURUR5 gURS:Xa2URURURUR5 gURS:Xa=URURURURUR 5 gg)Nrrrr)rrrroldr.rs rXr~_CallbackWrapper.__call__s ::? GGI ZZ1_ GGFKK ZZ1_ GGFKK , ZZ1_ GGFKKVZZ 8 ZZ1_ GGFKKVZZ FrW)rrN)rrrr)rXrrr]rrrr) rRrSrTrUrrzrr~rVrQrWrXrr{s R* GrWrcF[U[5(aU$[U5$rZ)rgr)rs rX_callback_wrapperrs "&'' ##rWcv^\rSrSrSrSU4SjjrSU4SjjrS SjrSrU=r $) r6izA metaclass for HasDescriptors. This metaclass makes sure that any TraitType class attributes are instantiated and sets their name attribute. c >UR5HQupV[R"U5(dM"[U[5(dM9[ S[ SS9 U"5X5'MS [TU] "XX#40UD6$)z Create the HasDescriptors class.Traits should be given as instances, not types (for example, `Int()`, not `Int`). Passing types is deprecated in traitlets 4.1.rr) itemsr isclassrir>rrsuper__new__)mclsrbases classdictkwdskvrOs rXrMetaHasDescriptors.__new__slOO%DAq!!jI&>&>E&  !s &wt5DtDDrWc L>[TU]"XU40UD6 URU5 g)z-Finish initializing the HasDescriptors class.N)rrz setup_class)rrrrrrOs rXrzMetaHasDescriptors.__init__s% i848  "rWcP/Ul/UlUR5H-up#[U[5(dMUR X5 M/ [ U5HHupC[U[5(dMURU5 URRU5 MJ g)zSetup descriptor instance on the class This sets the :attr:`this_class` and :attr:`name` attributes of each BaseDescriptor in the class dict of the newly created ``cls`` before calling their :attr:`class_init` method. N) _descriptorsrrrgrrrrr)rrrr_s rXrMetaHasDescriptors.setup_classs+-OO%DA!^,, S$&sODA!^,,$  ''*$rWrQ) rztype[MetaHasDescriptors]rrnrtuple[type, ...]rrrrrr6) rrnrrrrrrrr)rr6rrrr) rRrSrTrUrrrzrrV __classcell__rOs@rXr6r6s E&EE E$ E  E  E0##/#0Ul0Ul0Ul0Ul[T U]U5 UR 5n[U5GHn[X5n[U[5(dM'X@RU'UnSU-nUnUSURUR5S-nUHonXhR;aURUURU' MX8RR!S05;dMRURUURU' M UR"SL=(a UR$n ['U5[([*4;a[UR,cNUR.cA[UR"[05(dU (aUR"URU'GO ['U5[2[44;a[UR,cNUR.cA[UR"[65(dU (aUR"URU'GO['U5[8[:4;aA[UR"[<5(dU (aUR"URU'GO;['U5[>[@4;a@[UR"[B5(dU (aUR"URU'O['U5[D:XaP[UR"[B[0[6[<45(dU (aUR"URU'O['U5[F:XaUR"cSURU'OO[U[H5(a:URJc-URLc UR$(aSURU'URNURU'GM g![a GMf=f![a GNQf=f)N _%s_defaultr_trait_default_generators)(r_all_trait_default_generators_traits _static_immutable_initial_valuesrrmrorrrrgr>indexrrd__dict__rrrrhrr2minmaxintrr*floatrrr]rrArnrrCr1 default_argsdefault_kwargsrF) rrrrrwrKdefault_method_name mro_traitcnone_okrOs rXrMetaHasTraits.setup_classs,:<%,.) /1, I&ggiHD *%++$) D!&3d&:#  #$Ecii0@0@&AA&E FI#A*jj8BC**M`Ba99$?zz~~.I2NNBCB]B]^bBc99$? #$11T9Ne>N>NGU c{2!II-!II-'(;(;SAAWEJEXEX<A decorator which can be used to observe Traits on a class. The handler passed to the decorator will be called with one ``change`` dict argument. The change dictionary at least holds a 'type' key and a 'name' key, corresponding respectively to the type of notification and the name of the attribute that triggered the notification. Other keys may be passed depending on the value of 'type'. In the case where type is 'change', we also have the following keys: * ``owner`` : the HasTraits instance * ``old`` : the old value of the modified trait attribute * ``new`` : the new value of the modified trait attribute * ``name`` : the name of the modified trait attribute. Parameters ---------- *names The str names of the Traits to observe on the object. type : str, kwarg-only The type of event to observe (e.g. 'change') z2Please specify at least one trait name to observe.z5trait names to observe must be strings or All, not %rr)rorrgrnr9)rhrprs rXrJrJ8sO, LMM s?:dC#8#8SVZZ[ [ % ++rWFuncTct^[[4SU4Sjjjn[R"[U5$)a:Backward-compatibility shim decorator for observers Use with: @observe('name') @observe_compat def _foo_changed(self, change): ... With this, `super()._foo_changed(self, name, old, new)` in subclasses will still work. Allows adoption of new observer API without breaking subclasses that override and super. c>[U[5(a [U5nO9URRn[ SUSUS3[ SS9 [SUUUUS9nT"X5$)Nz A parent of z._zA_changed has adopted the new (traitlets 4.1) @observe(change) APIrrr)rhrrrr.)rgdictrrOrRrr)rychange_or_namerrrclsnamefuncs rXcompatible_observer+observe_compat..compatible_observerdsu nd + +>*Fnn--G wir.)99z{"  # FD!!rW) ryrrrnrrrrrr)rBr[r\r)rrs` rXrKrKVsQ8Ay""%("/4"GL" ""* 66%, --rWrEcU(d [S5eUH1nU[LdM[U[5(aM%[SU-5e [ U5$)ahA decorator to register cross validator of HasTraits object's state when a Trait is set. The handler passed to the decorator must have one ``proposal`` dict argument. The proposal dictionary must hold the following keys: * ``owner`` : the HasTraits instance * ``value`` : the proposed value for the modified trait attribute * ``trait`` : the TraitType instance associated with the attribute Parameters ---------- *names The str names of the Traits to validate. Notes ----- Since the owner has access to the ``HasTraits`` instance via the 'owner' key, the registered cross validator could potentially make changes to attributes of the ``HasTraits`` instance. However, we recommend not to do so. The reason is that the cross-validation of attributes may run in arbitrary order when exiting the ``hold_trait_notifications`` context, and such changes may not commute. z3Please specify at least one trait name to validate.z6trait names to validate must be strings or All, not %r)rorrgrnrE)rprs rXrMrM|sO2 MNN s?:dC#8#8TW[[\ \ 5 !!rWr%c^[U[5(d[SU-5e[U5$)aA decorator which assigns a dynamic default for a Trait on a HasTraits object. Parameters ---------- name The str name of the Trait on the object whose default should be generated. Notes ----- Unlike observers and validators which are properties of the HasTraits instance, default value generators are class-level properties. Besides, default generators are only invoked if they are registered in subclasses of `this_type`. :: class A(HasTraits): bar = Int() @default('bar') def get_bar_default(self): return 11 class B(A): bar = Float() # This trait ignores the default generator defined in # the base class A class C(B): @default('bar') def some_other_default(self): # This default generator should not be return 3.0 # ignored since it is defined in a # class derived from B.a.this_class. z*Trait name must be a string or All, not %r)rgrnror%)rs rXrFrFs.H dC DtKLL $ rW.)boundc\rSrSrS Sjr\R S Sj5r\R S Sj5rS SjrS S SjjrSr g)r)icXlU$rZr)ryrs rX _init_callEventHandler._init_calls   rWcgrZrQ)ryrrgrs rXr~EventHandler.__call__r:rWcgrZrQryrgrs rXr~rr:rWcl[US5(aUR"U0UD6$UR"U0UD6$)zCPass `*args` and `**kwargs` to the handler's function if it exists.r)r"rrrs rXr~rs7 4 99d-f- -??D3F3 3rWNcNUcU$[R"URU5$rZ)rrr)ryinstrs rXr8EventHandler.__get__s# <K 400rWr)rrrr))rrrgrrrrrrgrrrrrrZ)rrrrrztypes.MethodType | EventHandler) rRrSrTrUrr[rr~r8rVrQrWrXr)r)sFZZ  ZZ  411rWr)c,\rSrSrSSSjjrSSjrSrg) r9icXlX lgrZ trait_namesrh)ryrprhs rXrzObserveHandler.__init__s   rWcLURXRURS9 g)Nr)rJrrhryrs rXrObserveHandler.instance_inits T++$)) [TU]X5 XRUR'grZ)rrrrryrrrOs rXrDefaultHandler.class_inits" 3%9=%%doo6rWr)rrnrrr)rRrSrTrUrzrrVrrs@rXr%r%s>>rWc:^\rSrSrSrSU4SjjrSSjrSrU=r$)r/iz5The base class for all classes that have descriptors.c>USnUSSn[[U] nU[RLa U"U5nO U"U/UQ70UD6nUR"U0UD6 U$r)rr/rrsetup_instance)rgrrnew_methrrOs rXrHasDescriptors.__new__sf1gABx5 v~~ %C=DC1$1&1D T,V, rWctUSnUSSnSUlURnURH nU"U5 M g)z4 This is called **before** self.__init__ is called. rrNF)r1rOr)rgrryrinits rXrHasDescriptors.setup_instancesB AwABx&+#nn ''D J(rWr1rrgrrrrr) rRrSrTrUrrrrVrrs@rXr/r/s? rWr/) metaclassc^\rSrSr%S\S'S\S'S\S'S\S'S\S 'S\S 'S\S 'S-U4S jjrS-U4S jjrS.SjrS/Sjr\ \ RS0Sj55r \ RS0Sj5r S1SjrS2SjrS3SjrS4SjrS5SjrS6S7Sjjr\S4S8Sjjr\S4S8Sjjr\4S9SjjrS:SjrS;SjrSS j5r\S>U4S!jj5rS?S"jrS?S#jr S@S$jr!SAS%jr"SBS&jr#SCS'jr$SDS(jr%SESFS)jjr&\SGU4S*jj5r'\SESHS+jj5r(S,r)U=r*$)Ir0i"rr)rzdict[str | Sentinel, t.Any]_trait_notifiersrNr]r1rrc>USnUSSnURR5Ul0Ul0UlSUl[ [U]""U0UD6 g)NrrF) rrr)r rNr1rr0r)rgrryrOs rXrHasTraits.setup_instance+s\AwABx "BBGGI "!#&+# i-t>v>rWc z>Un0nU(aS SjnXPlSUl0nUR5H<upxURU5(a[ XU5 [ USUUSS9Xg'M8XU'M> [ U5[ UR5-n U HCnURURU[X55nURXx5 XUS'ME SUlU?U HnURXg5 M [TU]0"U0UD6 g![an UV s/sHn [U 5PM Os sn fn n UR5HupU RU SU<35 M SR!U 5n[#S R%UUR&R(U S 9[*S S 9 Sn A gSn A ff=f)NrcgrZrQ)rs rXignore"HasTraits.__init__..ignoreCsrWTrrrr.rhrF=z, zPassing unrecognized arguments to super({classname}).__init__({arg_s}). {error} This is deprecated in traitlets 4.2.This error will be raised in a future release of traitlets.)arg_s classnamerjrrr) notify_changer1r has_traitrrrBrrHr set_traitrrzror}rrhrrirOrRr)ryrgr super_args super_kwargsrchangesrrwchangedr4arg arg_s_listrrrrOs rXrzHasTraits.__init__9s   "( *.D 'G$lln >>#&&Du-#(  !"% $GL).%-&kC $55G S)99$@RSs*&+ U#+0D '"""7<0  G j 9L 9 /9:z$s)z:J:$**,!!QCq,/-IIj)E NOUf"nn55OUO #   s%D F:F5 D65A;F55F:cURR5n0US'0US'URR5US'SUS'U$)Nr rNr)Fr1)rrr))ryds rX __getstate__HasTraits.__getstate__vsU MM   !# !# !//446/&+ "#rWcUR5UlURn[U5H7n[ X#5n[ U[ 5(aURU5 M7M9 g![a MIf=frZ) rrrOrrrgr)rr)rystaterrrws rX __setstate__HasTraits.__setstate__sm  nns8C .)e\22''-3 "  s A)) A76A7c#v# UR(aSv gSUlSv SUlg!SUlf=f7f)z A contextmanager for running a block with our cross validation lock set to True. At the end of the block, the lock's value is restored to its value prior to entering the block. NTFrrs rXcross_validation_lockHasTraits.cross_validation_locks6  & &   4.2+.3+e+s9 -9 69c#~^^ # UR(aSv g0mS Sjm S UU 4SjjnXlSUlSv [TR55HEn[ UR U5nUR U[ X55nURX$5 MG SUlU?TR5HnUHnURU5 M M g![anSUlTR5Hqup&USSS2H`nURS:XdMUR[LaURX'R5 MEURRU5 Mb Ms 0mUeSnAff=f!SUlU?TR5HnUHnURU5 M M f=f7f) a Context manager for bundling trait change notifications and cross validation. Use this when doing multiple trait assignments (init, config), to avoid race conditions in trait notifiers requesting other trait values. All trait notifications will fire after all values have been assigned. NrcUcU/$USSS:Xa$URS:XaURUSS'U$URU5 U$)z5Merges the provided change with the last if possible.rrhrr)rhrr) past_changesrs rXcompress4HasTraits.hold_trait_notifications..compresss]'"8O#B'/8; x@W28** R(/('%++F3''rWcT>URnT"TRU5U5TU'grZ)rr)rrcacher,s rXhold0HasTraits.hold_trait_notifications..holds${{&uyy?d rWTcgrZrQrs rXr4HasTraits.hold_trait_notifications..strWrF)r+zlist[Bunch] | Nonerrrz list[Bunch]r)r1rlistrvrrOrHrr=rrhrrBr)popvalues) ryr0rrKrwr4rrr/r,s @@rXhold_trait_notifications"HasTraits.hold_trait_notificationss  & &  ,.E ( @ @ 3&*".2+ .D#DNND9E!11$8KLENN4//$/4+& %||~G")**62#* .' %3"%*[[]MD")$B$-!;;(2%zz: $tZZ @ $ 2 2 6 6t < #0&3 /4+& %||~G")**62#* .s<'F=A3C ;F= E;%6E6AE66E;;E>>HasTraits._notify_traits'     rWrc$URU5$)z"Notify observers of a change event)r2rs rXrHasTraits.notify_changes%%f--rWc[U[5(d [U5nUSUSp2/nX R;azURURR U05R U/55 URURR U05R [ /55 [ UR;aURURR [ 05R U/55 URURR [ 05R [ /55 SU-nUSS:Xa}[ X5(am[URU5n[U[5(dB[UURUS5 [X5nXt;aUR[U55 UHdn[U[5(a URnO7[U[5(a"UR b[XR 5nU"U5 Mf g)zNotify observers of any eventrrhz _%s_changedrz$use @observe and @unobserve instead.N)rgrr extendrrr"rrOr9rrrrr~r)r) ryeventrrh callables magic_name class_valuerrs rXr2HasTraits._notify_observerss%''%LE6]E&Md (( (   T2266tR@DDT2N O   T2266tR@DDS"M N $'' '   T2266sB?CCD"M N   T2266sB?CCCL M#T) =H $)B)B!$..*=Kk>::!NN:  T.&$$%6r%:;A!-..JJA|,,1CD&&) eHrWcX R;a/nX40URU'O8X0RU;a/nX@RUU'OURUUnX;aURU5 ggrZ)r r)ryhandlerrrhnlists rX_add_notifiersHasTraits._add_notifiers"s| ,, ,!#E+/-D ! !$ '006649%%d+D1--d3D9   LL ! rWcUcURUU gURUURU5 g![a gf=frZ)r remover/)ryrErrhs rX_remove_notifiersHasTraits._remove_notifiers1sO ))$/5%%d+D188A   s8!8 AAc[S[SS9 Uc[nU(aUR[ U5US9 gUR [ U5US9 g)aDEPRECATED: Setup a handler to be called when a trait changes. This is used to setup dynamic notifications of trait changes. Static handlers can be created by creating methods on a HasTraits subclass with the naming convention '_[traitname]_changed'. Thus, to create static handler for the trait 'a', create the method _a_changed(self, name, old, new) (fewer arguments can be used, see below). If `remove` is True and `handler` is not specified, all change handlers for the specified name are uninstalled. Parameters ---------- handler : callable, None A callable that is called when a trait changes. Its signature can be handler(), handler(name), handler(name, new), handler(name, old, new), or handler(name, old, new, self). name : list, str, None If None, the handler will apply to all traits. If a list of str, handler will apply to all names in the list. If a str, the handler will apply just to that name. remove : bool If False (the default), then install the handler. If True then unintall it. zCon_trait_change is deprecated in traitlets 4.1: use observe insteadrrNr)rrrrrrJ)ryrErrJs rXon_trait_changeHasTraits.on_trait_change<sQB Q  <D  NN,W5TN B LL*734L @rWcL[U5HnURXU5 M g)aYSetup a handler to be called when a trait changes. This is used to setup dynamic notifications of trait changes. Parameters ---------- handler : callable A callable that is called when a trait changes. Its signature should be ``handler(change)``, where ``change`` is a dictionary. The change dictionary at least holds a 'type' key. * ``type``: the type of notification. Other keys may be passed depending on the value of 'type'. In the case where type is 'change', we also have the following keys: * ``owner`` : the HasTraits instance * ``old`` : the old value of the modified trait attribute * ``new`` : the new value of the modified trait attribute * ``name`` : the name of the modified trait attribute. names : list, str, All If names is All, the handler will apply to all traits. If a list of str, handler will apply to all names in the list. If a str, the handler will apply just to that name. type : str, All (default: 'change') The type of notification to filter by. If equal to All, then all notifications are passed to the observe handler. N)rLrGryrErprhrs rXrJHasTraits.observeis#>(.D   t 4/rWcL[U5HnURXU5 M g)anRemove a trait change handler. This is used to unregister handlers to trait change notifications. Parameters ---------- handler : callable The callable called when a trait attribute changes. names : list, str, All (default: All) The names of the traits for which the specified handler should be uninstalled. If names is All, the specified handler is uninstalled from the list of notifiers corresponding to all changes. type : str or All (default: 'change') The type of notification to filter by. If All, the specified handler is uninstalled from the list of notifiers corresponding to all types. N)rLrKrQs rXrHasTraits.unobserves#,(.D  " "7$ 7/rWcbU[La0UlgURU g![a gf=f)zwRemove trait change handlers of any type for the specified name. If name is not specified, removes all trait notifiers.N)rr r/rs rX unobserve_allHasTraits.unobserve_alls8 3;$&D ! ))$/  s ! ..cUH_nSU-n[X5(dM[URU5n[U[5(aMG[ UURUS5 Ma UHnXR U'M g)aSetup a handler to be called when a trait should be cross validated. This is used to setup dynamic notifications for cross-validation. If a validator is already registered for any of the provided names, a TraitError is raised and no new validator is registered. Parameters ---------- handler : callable A callable that is called when the given trait is cross-validated. Its signature is handler(proposal), where proposal is a Bunch (dictionary with attribute access) with the following attributes/keys: * ``owner`` : the HasTraits instance * ``value`` : the proposed value for the modified trait attribute * ``trait`` : the TraitType instance associated with the attribute names : List of strings The names of the traits that should be cross-validated rLrMN)r"rrOrgrErrN)ryrErprrArBs rXrHasTraits._register_validatorsr,D'$.Jt((%dnnjA !+??%#":  D+2 " "4 (rWc $URnSUR0n[US5(aURUS'UR U5 [ UR U4U5UlUR5HnURU5 M g)z;Dynamically add trait attributes to the HasTraits instance.rSrTN) rOrSr"rTrrhrRr6r)ryrrattrsrKs rX add_traitsHasTraits.add_traitssvnns~~. 3 ' '$'$4$4E. ! VcllSFE:]]_E    %%rWcURnURU5(d[SURSU35e[ X15R X5 g)z>Forcibly sets trait attribute, including read-only attributes.Class  does not have a trait named N)rOrr=rRrrB)ryrrwrs rXrHasTraits.set_traitsLnn~~d##vcll^3PQUPVWX Xt+rWc 8[UR"S0UD65$)z}Get a list of all the names of this class' traits. This method is just like the :meth:`trait_names` method, but is unbound. rQ)r4 class_traits)rrs rXclass_trait_namesHasTraits.class_trait_namessC$$0x011rWc VURR5n[U5S:XaU$0nUR5HgupEUR5HJupg[ U5(d [ U5nU"UR RUS55(aMI Ma XSU'Mi U$)a|Get a ``dict`` of all the traits of this class. The dictionary is keyed on the name and the values are the TraitType objects. This method is just like the :meth:`traits` method, but is unbound. The TraitTypes returned don't know anything about the values that the various HasTrait's instances are holding. The metadata kwargs allow functions to be passed in which filter traits based on metadata values. The functions should take a single value as an argument and return a boolean. If any function returns False, then the trait is not included in the output. If a metadata key doesn't exist, None will be passed to the function. rNrrrrcallablersrr)rrrresultrrK meta_name meta_evals rXrcHasTraits.class_traitss"!!# x=A M!<<>KD(0(8$  ** +I 6I !3!3It!DEE )9 %t * rWc >[X5nUR"S0UD6R5VVs0sHup4[X#S5ULdMX4_M snn$s snnf)zGet a dict of all the traitlets defined on this class, not a parent. Works like `class_traits`, except for excluding traits from parents. NrQ)rrcrr)rrsuprqr[rOs rXclass_own_traitsHasTraits.class_own_traitssaCo**6X6<<> >st$A- AD>   s A AcXR;$)z?Returns True if the object has a trait with the specified name.rrs rXrHasTraits.has_trait s||##rWcXR;$)aReturns True if the specified trait has a value. This will return false even if ``getattr`` would return a dynamically generated default value. These default values will be recognized as existing only after they have been generated. Example .. code-block:: python class MyClass(HasTraits): i = Int() mc = MyClass() assert not mc.trait_has_value("i") mc.i # generates a default value assert mc.trait_has_value("i") )r)rs rXtrait_has_valueHasTraits.trait_has_value$s*))))rWc dUR"S0UD6Vs0sHo"[X5_M sn$s snf)apA ``dict`` of trait names and their values. The metadata kwargs allow functions to be passed in which filter traits based on metadata values. The functions should take a single value as an argument and return a boolean. If any function returns False, then the trait is not included in the output. If a metadata key doesn't exist, None will be passed to the function. Returns ------- A ``dict`` of trait names and their values. Notes ----- Trait values are retrieved via ``getattr``, any exceptions raised by traits or the operations they may trigger will result in the absence of a trait value in the result ``dict``. rQ)rr)ryrrs rX trait_valuesHasTraits.trait_values;s4(7;6F6F6R6RS6Rdgd))6RSSSs-cSU-nX R;a [X5$X RR;a[URU5$URU$)z|Return default generator for a given trait Walk the MRO to resolve the correct default generator according to inheritance. r)rrrOr)ryr method_names rX_get_trait_default_generator&HasTraits._get_trait_default_generatorQsU $d* -- '4- - ..11 14>>;7 711$77rWc UH>nURU5(aM[SUS[U5RS35e [ U5S:XaB[ U5S:Xa3[ R "[URUS5"U55$UR"S0UD6nURU5 0nUHnURU5"U5XS'M U$)zReturn a trait's default value or a dictionary of them Notes ----- Dynamically generated default values may depend on the current state of the object.'z' is not a trait of 'z ' instancesrrrQ) rr=rhrRrr[r\rr|rr>)ryrprrqrdefaultss rXr0HasTraits.trait_defaults]sA>>!$$ 1QC'tDHKrWc 8[UR"S0UD65$)z2Get a list of all the names of this class' traits.rQ)r4r)ryrs rXrHasTraits.trait_namesssDKK+(+,,rWc VURR5n[U5S:XaU$0nUR5HgupEUR5HJupg[ U5(d [ U5nU"UR RUS55(aMI Ma XSU'Mi U$)a7Get a ``dict`` of all the traits of this class. The dictionary is keyed on the name and the values are the TraitType objects. The TraitTypes returned don't know anything about the values that the various HasTrait's instances are holding. The metadata kwargs allow functions to be passed in which filter traits based on metadata values. The functions should take a single value as an argument and return a boolean. If any function returns False, then the trait is not included in the output. If a metadata key doesn't exist, None will be passed to the function. rNrg)ryrrrirrKrjrks rXrHasTraits.traitsws""$ x=A M!<<>KD(0(8$  ** +I 6I !3!3It!DEE )9 %t * rWcX[URU5nSU-S-n[ X5(a)U[X5;a[X5R X#5$URR X#5$![a+n[SURRSU35UeSnAff=f)z%Get metadata values for trait by key.r_r`Nr _metadata)rrOrr=rRr"rr)ry traitnamerrFrKr4 metadata_names rXtrait_metadataHasTraits.trait_metadatas DNNI6E i+5 4 ' 'C743O,O4/33CA A>>%%c3 3 0011NykZ  sA44 B)>&B$$B)c >[X5nURU5R5VVs0sHup4[X#S5ULdMX4_M snn$s snnf)zGet a dict of all event handlers defined on this class, not a parent. Works like ``event_handlers``, except for excluding traits from parents. N)reventsrr)rrrnrqr4rOs rXclass_own_trait_events HasTraits.class_own_trait_eventss\ Co**T*002 2st$A- AD2   s AAc0n[U5Htup4[U[5(dMUcXBU'M%XR;aXBU'M:[ US5(dMMUR"S0UR D6(dMpXBU'Mv U$)aFGet a ``dict`` of all the event handlers of this class. Parameters ---------- name : str (default: None) The name of a trait of this class. If name is ``None`` then all the event handlers of this class will be returned instead. Returns ------- The event handlers associated with a trait name, or all event handlers. tagsrQ)rrgr)rr"r)rrrrrs rX trait_eventsHasTraits.trait_eventsstsODA!\**< !1I]]* !1IQ''000$%q $ rW)rOrr1r rNr)rr)rr)r#rrrr)rrnr@rr?rrrr)r?rrr)rEt.Callable[..., t.Any]rSentinel | strrhstr | Sentinelrr)rEzt.Callable[..., t.Any] | Nonerrrhrrr)NNF)rEzEventHandler | NonerzSentinel | str | NonerJr]rr)rErrp+Sentinel | str | t.Iterable[Sentinel | str]rhrrr)rz str | t.Anyrr)rEzt.Callable[..., None]rpztuple[str | Sentinel, ...]rr)rrrr)rrnrwrrr)rrrrr list[str])rrrrr"dict[str, TraitType[t.Any, t.Any]])rrnrr])rrrr)rrnrr)rprnrrrzdict[str, t.Any] | Sentinel)rrrr)rrrrrZ)rrnrrnrFrrr)rrrrnrdict[str, EventHandler])rrrrrr)+rRrSrTrUrrrzr r$propertyrrr'r7r>rr2rGrKrNrrJrrVrr\r classmethodrdrcrorrurxr|r0rrrrrrVrrs@rXr0r0"sV##&661122  #33 ?;z ."44$>3>3@  .)V "- "5C "KY "  " 4 A' 5' 5; 5 5  5J>A' 8'8;8 8  8214 "3,"35O"3 "3H &,22B    */  +    $*.T, 8,-> 4    rWr0c"\rSrSrSrSSjrSrg)r"izY A trait with error reporting and string -> type resolution for Type, Instance and This. c[U5$)z= Resolve a string supplied for a type into an actual object. r )rystrings rX_resolve_string#ClassBasedTraitType._resolve_strings6""rWrQNrrnrrrRrSrTrUrrrVrQrWrXr"r"s  #rWr"c^\rSrSrSr\R (a\RSSSjj5r\RSSSjj5r\RSSSjj5r\RSSSjj5r\ SSSSS4SU4S jjjrSS jr SS jr SS jr SS jr SSjrSrU=r$)r@izU[La Uc[OUnOUnUcUb U[La[nOUn[R"U5(d [ U[ 5(d [ S5eX l[T U]$"U4UUUUS.UD6 g)aConstruct a Type trait A Type trait specifies that its values must be subclasses of a particular class. If only ``default_value`` is given, it is used for the ``klass`` as well. If neither are given, both default to ``object``. Parameters ---------- default_value : class, str or None The default value must be a subclass of klass. If an str, the str must be a fully specified class name, like 'foo.bar.Bah'. The string is resolved into real class, when the parent :class:`HasTraits` class is instantiated. klass : class, str [ default object ] Values of this trait must be a subclass of klass. The klass may be specified in a string like: 'foo.bar.MyClass'. The string is resolved into real class, when the parent :class:`HasTraits` class is instantiated. allow_none : bool [ default False ] Indicates whether None is allowed as an assignable value. **kwargs extra kwargs passed to `ClassBasedTraitType` Nz"A Type trait must specify a class.)rrr r) rBrr rrgrnr=rrrz) ryrrrrr rrnew_default_valuerOs rXrzrsF I %+0=u  -  =%=I+E%&&*UC*@*@AB B    !    rWc h[U[5(aURU5n[ X R5(a[R"[U5$URX5 g![a&n[ SUR SUSU<S35UeSnAff=f![a NQf=f)z4Validates that the value is a valid object instance.zThe ' ' trait of z instance must be a type, but z could not be importedN) rgrnr ImportErrorr=rrirr[r\rr3rjryrrwr4s rXrM Type.validateWs eS ! ! ,,U3  %,,vva''- 3  DII;k#6Ti57    s(A14B$1 B!;!BB!$ B10B1c[UR[5(a URnO0URRS-URR-nSU-nUR (aUS-$U$)#Returns a description of the trait.rza subclass of '%s' or None)rgrrnrSrRr)ryrris rXr\ Type.infois` djj# & &JJEJJ))C/$**2E2EEE%- ??J& & rWc$UR5 grZ_resolve_classesrs rXrType.instance_initt rWc[UR[5(a URUR5Ul[UR[5(a!URUR5UlggrZ)rgrrnrrrs rXrType._resolve_classesysZ djj# & &--djj9DJ d((# . .!%!5!5d6H6H!ID  /rWcURnUce[U[5(a [U5$[URSUR 35$)Nr)rrgrnr}rSrRrxs rXr~Type.default_value_reprsR""   eS ! !; 5++,Aenn-=>? ?rW)rr......)ryzType[type, type]rSentinel | None | strr None | strrLiteral[False]rrr rr t.Any | Nonerrrr)ryzType[type | None, type | None]rrrrr Literal[True]rrr rrrrrrr)ryz Type[S, S]rrrrrrrrr rrrrrrr)ryzType[S | None, S | None]rzS | Nonerrrrrrr rrrrrrr)rrrrrr]rrr rrrrrrrrrrwrrrrrr)rRrSrTrUrr[ TYPE_CHECKINGrrzrBrMr\rrr~rVrrs@rXr@r@sF 47 #),%("#& " 0  '  #   !      47 #(+%("#& 0 0  &  #   !       #),%("#&    '  #   !      '*(+%("#& * #  &  #   !      ) !%#: : :  :  :  : : :  : : x$  J @@rWr@c>^\rSrSr%SrSrS\S'\R(a\RSSSjj5r \RSSSjj5r \RSSSjj5r \RSSS jj5r SSU4S jjjr SS jr SS jr SS jr SSjrSSjrSSjrSSjrSrU=r$) r1izA trait whose value must be an instance of a specified class. The value can also be an instance of a subclass of the specified class. Subclasses can declare default classes by overriding the klass attribute Nstr | type[T] | Nonerc grZrQryrrgkwrrr rs rXrzInstance.__init__rrWc grZrQrs rXrzrrrWc grZrQrs rXrzrrrWc grZrQrs rXrzrrrWc ~>Uc URnUb7[R"U5(d[U[5(aXlO[ SU-5eUb [U[ 5(d [ S5eUb [U[5(d [ S5eX lX0l [TU],"SXEUS.UD6 g)aConstruct an Instance trait. This trait allows values that are instances of a particular class or its subclasses. Our implementation is quite different from that of enthough.traits as we don't allow instances to be used for klass and we handle the ``args`` and ``kw`` arguments differently. Parameters ---------- klass : class, str The class that forms the basis for the trait. Class names can also be specified as strings, like 'foo.bar.Bar'. args : tuple Positional arguments for generating the default value. kw : dict Keyword arguments for generating the default value. allow_none : bool [ default False ] Indicates whether None is allowed as a value. **kwargs Extra kwargs passed to `ClassBasedTraitType` Notes ----- If both ``args`` and ``kw`` are None, then the default value is None. If ``args`` is a tuple and ``kw`` is a dict, then the default is created as ``klass(*args, **kw)``. If exactly one of ``args`` or ``kw`` is None, the None is replaced by ``()`` or ``{}``, respectively. Nz+The klass attribute must be a class not: %rz)The 'kw' argument must be a dict or None.z,The 'args' argument must be a tuple or None.)rrr rQ) rr rrgrnr=rtuplerrrrz) ryrrgrrrr rrOs rXrzrsL =JJE  GOOE$:$:jPS>T>TJJURS S NJr4$8$8HI I  ju&=&=KL L   YJ$YRXYrWcURceUR(aUcU$[X R5(a[R"[ U5$UR X5 grZ)rrrgr[r\rrjr*s rXrMInstance.validate sNzz%%% ??u}L eZZ ( (66!U# # JJs "rWc[UR[5(a[UR5nO[ SUR5nUR (aUS- nU$)Nrar)rgrrnrr r)ryris rXr\ Instance.info sG djj# & & ,Fc4::.F ?? j F rWc$UR5 grZrrs rXrInstance.instance_init rrWc[UR[5(a!URUR5UlggrZ)rgrrnrrs rXrInstance._resolve_classes s. djj# & &--djj9DJ 'rWcURcURcgURceUR"UR=(d S0UR=(d 0D6$)NrQrrrrs rXr!Instance.make_dynamic_default sW    %D,?,?,Gzz%%%zzD--3T9L9L9RPRTTrWc4[UR55$rZ)r}r!rs rXr~Instance.default_value_repr! sD--/00rWcJ[R"[[U55$rZ)r[r\rrers rXrInstance.from_string$ svva+A.//rWrr)ryz Instance[T]rtype[T]rgtuple[t.Any, ...] | Nonerdict[str, t.Any] | Nonerrrrr rrrrr)ryzInstance[T | None]rrrgrrrrrrrr rrrrr)ryzInstance[t.Any]rrrgrrrrrrrr rrrrr)ryzInstance[t.Any | None]rrrgrrrrrrrr rrrrr)NNNFNN)rrrgrrrrr]rrr rrrrrrrrwrrT | Nonerrr)rrr`rnrr)rRrSrTrUrrrr[rrrzrMr\rrr!r~rrVrrs@rXr1r1s#'E & !-0*-),%("   + (  '  #       !-0*-(+%(" $  + (  &  #       !$-0*-),%(" !  + (  '  #       !$-0*-(+%(" (  + (  &  #      '+)-&* !%6Z#6Z'6Z $ 6Z  6Z  6Z6Z6Z 6Z6Zp# :U 100rWr1c"\rSrSrSrSSjrSrg)r,i( z; Mixin for forward-declared versions of Instance and Type. cdURRn[SRX!/55$)zn Find the specified class name by looking for it in the module in which our this_class attribute was defined. r)rrSr rh)ryrmodnames rXr$ForwardDeclaredMixin._resolve_string- s* //,,388W$5677rWrQNrrrQrWrXr,r,( s 8rWr,c\rSrSrSrSrg)r-i6 z# Forward-declared version of Type. rQNrRrSrTrUrrVrQrWrXr-r-6 rWr-c\rSrSrSrSrg)r+i< z' Forward-declared version of Instance. rQNrrQrWrXr+r+< rrWr+c>^\rSrSrSrSrSU4SjjrSSjrSrU=r $) r<iB aA trait for instances of the class containing this trait. Because how how and when class bodies are executed, the ``This`` trait can only have a default value of None. This, and because we always validate default values, ``allow_none`` is *always* true. z4an instance of the same type as the receiver or Nonec &>[TU]"S0UD6 g)NrZrrz)ryrrOs rXrz This.__init__L s ((rWcURce[X R5(dUcU$URX5 grZ)rrgrjr*s rXrM This.validateO s8*** e__ - -%-L JJs "rWrQ)rrrr)rrrwrrr) rRrSrTrUrrrzrMrVrrs@rXr<r<B sGI)##rWr<c^\rSrSrSrS U4SjjrS S U4SjjjrSU4SjjrSSjrSSjr SSjr SU4S jjr S r U=r $)rCiZ z'A trait type representing a Union type.c >[U5UlSRURVs/sHo3R5PM sn5Ul[ TU]"S0UD6 gs snf)aConstruct a Union trait. This trait allows values that are allowed by at least one of the specified trait types. A Union traitlet cannot have metadata on its own, besides the metadata of the listed types. Parameters ---------- trait_types : sequence The list of trait types of length at least 1. **kwargs Extra kwargs passed to `TraitType` Notes ----- Union([Float(), Bool(), Int()]) attempts to validate the provided values with the validation function of Float, then Bool, and finally Int. Parsing from string is ambiguous for container types which accept other collection-like literals (e.g. List accepting both `[]` and `()` precludes Union from ever parsing ``Union([List(), Tuple()])`` as a tuple; you can modify behaviour of too permissive container traits by overriding ``_literal_from_string_pairs`` in subclasses. Similarly, parsing unions of numeric types is only unambiguous if types are provided in order of increasing permissiveness, e.g. ``Union([Int(), Float()])`` (since floats accept integer-looking values). z or NrQ)r4rVrhr\rrrz)ryrVrttrOs rXrzUnion.__init__] sS8 ,$:J:J%K:JBggi:J%KL "6"&LsA!c>[TU]U5nURH nU[LaURU5nM U$ U$rZ)rrFrVrB)ryrrFrKrOs rXrF Union.default} sF'/#&%%E)#--, & rWc>[UR5HnURUS5 M [TU] X5 grZ)reversedrVrr)ryrr trait_typerOs rXrUnion.class_init s5"4#3#34J  ! !#t ,5 3%rWc^[UR5HnURU5 M grZ)rrVr)ryrrs rXrUnion.subclass_init s%"4#3#34J  $ $S )5rWc\UR URHTnURX5nURb'[ USUR-S-UR 5 Us sSSS5 $ SSS5 URX5 g![ a Mf=f!,(df  N1=f)Nrr)r'rVr(rrrr=rj)ryrrwrrs rXrMUnion.validate s  & &".. ",,S8Ayy,S499_{%BJDWDWXH' &.' 3"' &s5BAB $B0B BBBB B+c[U[5(a"[URUR-5$[/URQUP5$rZrUrWs rXrY Union.__or__ sG eU # #))E,=,==> >34++3U34 4rWc>URH'nURU5nURSU5s $ [ TU]U5$![[4a MMf=frZ)rVrrMr=rdr)ryr`rrrOs rXrUnion.from_string sf**J **1-!**433+ w"1%% +  s"AAA)rrV)rVrrrrrrZ)rrrrrrrrrrrrwrrr)rXrrrCr`rnrr)rRrSrTrUrrzrFrrrMrYrrVrrs@rXrCrCZ s41#@& * 5 &&rWrCc\rSrSr%Sr\R (a\RSSSSS.SSjjj5r\RSSSSS.SSjjj5r\RSSSS S S .SS jjj5rSS S S S S .SSjjjr\RSSj5r \RSSj5r SSjr S r S\ S'Sr Sr SSjrSrg )ri zA trait which allows any value..rr rrrc grZrQryrrrr rrs rXrz Any.__init__ rrWc grZrQrs rXrzr rrWFN)rr rrc grZrQryrrr rrrs rXrzr rrWrc grZrQrs rXrzr  rWcgrZrQr7s rXr8 Any.__get__  rWcgrZrQr7s rXr8r rrWcgrZrQr7s rXr8r s rWTrcgrZrQrs rXrAny.subclass_init  rWrQ).)ryrrrrrrrr rrrrrrr)ryrrrrrrrr rrrrrrr)ryrrrrLiteral[True, False]r rrrrrrrrr)ryrrrrr]r rrrrrrrrr)rrrrrr)rrrrrr)rrrrrz t.Any | Anyr )rRrSrTrUrr[rrrzr8rrrrrrVrQrWrXrr s1) $'  &)"#&    '  #   !      $'  &)"#&    &  #   !      $' 03"%*     -    #      $'  %!%*         #             #'M<&JI rWrc JURbDX R:a5[SURS[U5SURSUS3 5eURbDX R:a5[SURS[U5SURSUS3 5eU$)z Validate that a number to be applied to a trait is between bounds. If value is not between min_bound and max_bound, this raises a TraitError with an error message appropriate for this trait. zThe value of the 'rz" instance should not be less than , but a value of z was specifiedz% instance should not be greater than )rr=rrr)rKrrws rX_validate_boundsr! s yy!2  K G % {*;E7C    yy!2  K G##(99+->ugF   LrWc&^\rSrSrSrSrSr\RSSSjj5r \RSSSjj5r \ SSSS4SU4S jjjr SS jr SS jr SS jr S rU=r$)r2i z An int trait.rzan intc grZrQrs rXrz Int.__init__  rWc grZrQrs rXrzr$+ r%rWFNc >URSS5UlURSS5Ul[TU]"SUUUUUS.UD6 g)Nrrrrrr rrQ)r5rrrrzryrrrr rrrOs rXrzr$7 sT::eT*::eT*  '!    rWc[U[5(dURX5 [R"[ [ XU55$rZ)rgrrjr[r\rr!r*s rXrM Int.validateK s4%%% JJs "vva)$U;<rr?rr]rrr rrrrrrrr rRrSrTrUrr[rrrzrMrVrQrWrXrrY s[- /2),%("#& " + ' #    !      69(+%("#& ) 2 & #    !     69"%("#& ) 2  #    !   =rWrc*^\rSrSrSrSrSr\RSSSjj5r \RSSSjj5r \ SSSS4SU4S jjjr SS jr SS jr SS jr S rU=r$)r*i zA float trait.gza floatc grZrQrs rXrzFloat.__init__ r%rWc grZrQrs rXrzrC r%rWFNc >URS[S5*5UlURS[S55Ul[TU]"SUUUUUS.UD6 g)Nrinfrr(rQ)r5rrrrrzr)s rXrzrC s^::eeEl]3::eU5\2  '!    rWc[U[5(a [U5n[U[5(dURX5 [R "[ [XU55$rZ)rgrrrjr[r\rr!r*s rXrMFloat.validate sJ eS ! !%LE%'' JJs "vva)$U;<\rSrSrSrSrSrS SjrS SjrS Sjr Sr g ) r#i zA trait for complex numbers.yza complex numberc[U[5(aU$[U[[45(a [U5$UR X5 grZ)rgcomplexrrrjr*s rXrMComplex.validate s; eW % %L eeS\ * *5> ! 3rWcHUR(aUS:Xag[U5$r-)rrYrs rXrComplex.from_string s ??qF{qzrWcgrZrQrs rXrComplex.subclass_init rrWrQNrrrwrrcomplex | None)r`rnrr`r  rRrSrTrUrrrrMrrrVrQrWrXr#r# s&M"I  rWr#c"\rSrSrSrSSjrSrg)ri z.A casting version of the complex number trait.c\[U5$![a URX5 gf=frZ)rYr3rjr*s rXrMCComplex.validate s, #5> ! # JJs " # ++rQNr_rRrSrTrUrrMrVrQrWrXrr s 8#rWrc>\rSrSrSrSrSrS SjrS SjrS Sjr Sr g ) ri" zA trait for byte strings.rWza bytes objectcT[U[5(aU$URX5 grZ)rgbytesrjr*s rXrMBytes.validate( s eU # #L 3rWcUR(aUS:Xag[U5S:aASH;nUSSSU3:XdMUSU:XdMUnUSSn[SU<SU<S 3[SS 9 O UR S 5$) Nrr"rrbrzISupporting extra quotes around Bytes is deprecated in traitlets 5.0. Use instead of rrutf8)rrrrencode)ryr`quoteold_ss rXrBytes.from_string- s ??qF{ q6Q;#Ra5awK'AbEUNE!BA e<y;*#$  $xxrWcgrZrQrs rXrBytes.subclass_init? rrWrQNrrrwrr bytes | None)r`rnrrxr rarQrWrXrr" s#M I  $ rWrc"\rSrSrSrSSjrSrg)riC z+A casting version of the byte string trait.c\[U5$![a URX5 gf=frZ)rir3rjr*s rXrMCBytes.validateF s, #<  # JJs " #rerQNrwrfrQrWrXrrC s 5#rWrc>\rSrSrSrSrSr\R(ao\RS SSjj5r \RS SSjj5r S SSjjr SSjr SS jr SS jr S rg )rAiM zA trait for unicode strings.rza unicode stringc grZrQrs rXrzUnicode.__init__U rrWc grZrQrs rXrzr~a rrWc grZrQrs rXrzr~m r:rWc [U[5(a[R"[U5$[U[ 5(a,[R"[UR SS55$URX5 g![a6nSn[URX R[U555UeSnAff=f)Nasciistrictz=5.r) rr[r\rospath expanduserrrr)ryr`rrss rXrUnicode.from_string s ??qF{66!T? " GG  q ! q6Q;Q41R5%A%%E!BA''(e<y@^`*#$   vva|rWcgrZrQrs rXrUnicode.subclass_init rrWrQNr2)ryzUnicode[str, str | bytes]rrrrrrr rrrrrrr)ry'Unicode[str | None, str | bytes | None]rstr | Sentinel | Nonerrrrr rrrrrrr)ryrrrrr]rrr rrrrrrrrr3r )rRrSrTrUrrrr[rrrzrMrrrVrQrWrXrArAM so&M"I -0),%(" + ) ' #          47(+%(" 9 0 & #         47"%(" 9 0  #        $ rWrAc"\rSrSrSr\R (ao\RS S Sjj5r\RS S Sjj5rS S SjjrS Sjr Sr g)ri z'A casting version of the unicode trait.c grZrQrs rXrzCUnicode.__init__ rrWc grZrQrs rXrzr rrWc grZrQrs rXrzr r:rWc[R"[[U55$![a UR X5 gf=frZ)r[r\rrnr3rjr*s rXrMCUnicode.validate s7 #66!SZ( ( # JJs " ##&AArQNr2)ryzCUnicode[str, t.Any]rrrrrrr rrrrrrr)ryCUnicode[str | None, t.Any]rrrrrrr rrrrrrr)ryrrrrr]rrr rrrrrrrrr@rQrWrXrr s[1 -0),%(" & ) ' #          47(+%(" - 0 & #         47"%(" - 0  #       #rWrcB\rSrSrSrSr\"S5rS SjrS Sjr Sr g) r8i zwA string holding a valid object name in this version of Python. This does not check that the name exists in any scope.z#a valid object identifier in PythoncU$rZrQ)rr`s rXrObjectName. s1rWcURX5n[U[5(a[U5(aU$UR X5 grZ) coerce_strrgrnr^rjr*s rXrMObjectName.validate s8+ eS ! !l5&9&9L 3rWc6UR(aUS:XagU$r-rrs rXrObjectName.from_string s ??qF{rWrQNrrrwrrrn)r`rnrr) rRrSrTrUrr staticmethodrrMrrVrQrWrXr8r8 s">6In-JrWr8c"\rSrSrSrSSjrSrg)r'i zFA string holding a valid dotted object name in Python, such as A.b3._ccURX5n[U[5(a([SUR S555(aU$UR X5 g)Nc38# UHn[U5v M g7frZ)r^)rbras rXrc,DottedObjectName.validate.. s)TCSa,q//CSsr)rrgrnallrrjr*s rXrMDottedObjectName.validate sG+ eS ! !c)T5;;sCS)T&T&TL 3rWrQNrrfrQrWrXr'r' s PrWr'cH\rSrSrSrSrSr\R(ao\RSSSjj5r \RSSSjj5r SSSjjr SSjr SS jr SS jr SS jrS rg )ri zA boolean (True, False) trait.Fz a booleanc grZrQrs rXrz Bool.__init__ rrWc grZrQrs rXrzr rrWc grZrQrs rXrzr r:rWc4[U[5(a[R"[U5$[U[ 5(aBUS:Xa[R"[S5$US:Xa[R"[S5$UR X5 g)NrTrF)rgr]r[r\rrrjr*s rXrM Bool.validate sh eT " "66!U# # s # #zvva&!vva'' 3rWc UR(a!US:Xa[R"[S5$UR 5nUS;a[R"[S5$US;a[R"[S5$[ S5e)Nr>1trueT>0falseFz%r is not 1, 0, true, or false)rr[r\rlowerrdrs rXrBool.from_string sg ??qF{66!T? " GGI 66!T? " . 66!U# #=> >rWcgrZrQrs rXrBool.subclass_init) rrWc R/SQnUR(aURS5 U$) Completion hints for argcomplete)rrrrr)rr)ryr completionss rX argcompleterBool.argcompleter, s"1 ??   v &rWrQNr2)ryzBool[bool, bool | int]rbool | Sentinelrrrrr rrrrrrr)ry$Bool[bool | None, bool | int | None]rbool | Sentinel | Nonerrrrr rrrrrrr)ryrrrrr]rrr rrrrrrrrr3r rrrr)rRrSrTrUrrrr[rrrzrMrrrrVrQrWrXrr st(MI .1),%(" ( * ' #          58(+%(" 6 1 & #         58"%(" 6 1  #        ? rWrc"\rSrSrSr\R (ao\RS S Sjj5r\RS S Sjj5rS S SjjrS Sjr Sr g)ri4 z'A casting version of the boolean trait.c grZrQrs rXrzCBool.__init__9 rrWc grZrQrs rXrzrE rrWc grZrQrs rXrzrQ r:rWc[R"[[U55$![a UR X5 gf=frZ)r[r\rr]r3rjr*s rXrMCBool.validate\ s7 #66!T%[) ) # JJs " #rrQNr2)ryzCBool[bool, t.Any]rrrrrrr rrrrrrr)ryCBool[bool | None, t.Any]rrrrrrr rrrrrrr)ryrrrrr]rrr rrrrrrrrr@rQrWrXrr4 s[1 .1),%(" $ * ' #          58(+%(" + 1 & #         58"%(" + 1  #       #rWrc^\rSrSrSr\R (aX\RSSSjj5r\RSSSjj5r\ SSSS4SU4SjjjrSSjr SSS jjr SSS jjr SS jr SS jrSS jrSSjrSSjrSrU=r$)r(ic z0An enum whose value must be in a given sequence.c grZrQryr6rrrr rrs rXrz Enum.__init__h rrWc grZrQrs rXrzru rrWFNc t>XlUSLa U[LaSnX7S'XGS'XWS'XgS'[TU] "U40UD6 g)NTrrr r)r6rBrrz) ryr6rrrr rrrOs rXrzr sO  -9"< M)|'{v!x 1&1rWcUR(a*X R;a[R"[U5$UR X5 grZ)r6r[r\rrjr*s rXrM Enum.validate s/ ;;5KK/66!U# # 3rWcUR=(d /nU(aSRSU55nU$[[U55nU$)6Returns a description of the trait choices (not none).|c3,# UH nSU-v M g7fz``%r``NrQrbrs rXrc$Enum._choices_str.. s!@1(Q,)r6rhr}r4)ryas_rstchoices choice_strs rX _choices_strEnum._choices_str sE++# !@!@@Jd7m,JrWcpUR(aSU(aSOS-OSnSURU5U3$r or %s`None`rrany of rrryrnones rX_info Enum._info 6>Booxv86:SU**623D6::rWc URSS9$NFrrrs rXr\ Enum.info zzz''rWc URSS9$NTrrrs rXinfo_rst Enum.info_rst zzz&&rWcURSU5$![a' [R"[[ U55s$f=frZ)rMr=r[r\rrers rXrEnum.from_string s> 4==q) ) 466!/23 3 4s.AAcgrZrQrs rXrEnum.subclass_init rrWc jUR=(d /Vs/sHn[U5PM sn$s snf)r)r6rn)ryrrs rXrEnum.argcompleter s, $ 1r 12 11A 1222s0)r6r2)ryEnum[G]r6z t.Sequence[G]rz G | Sentinelrrrrr rrrrrrr)ryzEnum[G | None]r6t.Sequence[G] | NonerG | Sentinel | Nonerrrrr rrrrrrr)ryrr6rrrrr]rrr rrrrrrrrFrr]rrnrr3r r)rRrSrTrUrr[rrrzrBrMrrr\rrrrrVrrs@rXr(r(c s: +.),%("  ! ( '  #         25(+%("   ( / &  #        .7 !%22$2+2 2  2  222 22& ; ('4  33rWr(ct^\rSrSrSr\4S U4SjjjrS SjrS S SjjrS Sjr S Sjr Sr U=r $)r!i z4An enum of strings where the case should be ignored.c ,>[TU]"U4SU0UD6 gNrr)ryr6rrrOs rXrzCaselessStrEnum.__init__ s G}GGrWcV[U[5(dURX5 UR=(d /HYn[U[5(deUR 5UR 5:XdM>[ R "[U5s $ URX5 grZ)rgrnrjr6rr[r\r)ryrrwrs rXrMCaselessStrEnum.validate sv%%% JJs """Aa%% %%wwyEKKM)vva|## 3rWcrUR(aSU(aSOS-OSnSURU5SU3$)rrrrrrz (case-insensitive)rrs rXrCaselessStrEnum._info s9>Booxv86:SU**6233FtfMMrWc URSS9$rrrs rXr\CaselessStrEnum.info rrWc URSS9$rrrs rXrCaselessStrEnum.info_rst rrWrQ) ryzCaselessStrEnum[t.Any]r6rrrrrrrrrrr) rRrSrTrUrrBrzrMrr\rrVrrs@rXr!r! sd> )H$HHH H  HHN (''rWr!c^\rSrSrSrSrSr\SS4S U4SjjjrS Sjr S S Sjjr SSjr SSjr S r U=r$)r.i zEAn case-ignoring enum matching choices by unique prefixes/substrings.Fc D>X0lX@l[TU] "U4SU0UD6 gr)case_sensitivesubstring_matchingrrz)ryr6rrrrrOs rXrzFuzzyEnum.__init__ s(-"4 G}GGrWc [U[5(dURX5 UR(aSOSnURnU(aSOSnU"U5nUR =(d /nUVs/sHou"X#"U55PM nn[ U5S:Xa[Xh5HupU (dMU s $ URX5 gs snf)NcU$rZrQrs rXr$FuzzyEnum.validate.. sqrWc"UR5$rZ)rrs rXrr s  rWc X;$rZrQrrs rXrr s16rWc$URU5$rZ) startswithrs rXrr sTUT`T`abTcrWr)rgrnrjrrr6sumzip) ryrrw conv_funcr match_funcrrmatchesrms rXrMFuzzyEnum.validate s%%% JJs "%)%8%8[>Q !44.@)Gc % ++#Booxv86:SU"11{} $ 7 7X4&&d.?.?.G-HOOrWc URSS9$rrrs rXr\FuzzyEnum.info rrWc URSS9$rrrs rXrFuzzyEnum.info_rst rrW)rr)ryzFuzzyEnum[t.Any]r6rrrrr]rr]rrrrrrrr)rRrSrTrUrrrrBrzrMrr\rrVrrs@rXr.r. sON )$#( H H H H H ! H  H  H H"P(''rWr.c^\rSrSr%SrSrS\S'SrS\S'\r Sr S\S 'S r S\S '\ RS S S S .SSjj5r\ RS S S S .SSjj5r\ RS S S S S S.SSjj5rS\SSS4SU4SjjjrSU4SjjrSSjrS U4SjjrS!SjrS"SjrS#SjrS$S%SjjrSrU=r$)&r$i zTAn instance of a container (list, set, etc.) To be subclassed by overriding klass. Nztype[T] | NonerrQr _cast_types_trait)[]()_literal_from_string_pairs.r c grZrQryrrr rrs rXrzContainer.__init__ r%rWc grZrQr5s rXrzr6' r%rW)rKrr rrc grZrQ)ryrKrr rrrs rXrzr63 s rWc >UbU[La[U5(dUnSnUcDURSS5(d-[SURR S3[ SS9 [nU[LaSnONUcSnSUS 'OC[X R5(aU4nO%[S URR S U35e[U5(aH[U[5(a[S [ S S9 [U[5(aU"5OUUl OUb[S[U5-5e[TU]8"SURXsXES.UD6 g)aFCreate a container trait type from a list, set, or tuple. The default value is created by doing ``List(default_value)``, which creates a copy of the ``default_value``. ``trait`` can be specified, which restricts the type of elements in the container to that TraitType. If only one arg is given and it is not a Trait, it is taken as ``default_value``: ``c = List([1, 2, 3])`` Parameters ---------- trait : TraitType [ optional ] the type for restricting the contents of the Container. If unspecified, types are not checked. default_value : SequenceType [ optional ] The default value for the Trait. Must be list/tuple/set, and will be cast to the container type. allow_none : bool [ default False ] Whether to allow the value to be None **kwargs : any further keys for extensions to the Trait (e.g. config) NrF Specifying a(default_value=None) for no default is deprecated in traitlets 5.0.5. Use default_value=UndefinedrrrQrdefault value of  was rrz'`trait` must be a Trait or None, got %s)rrgr rr)rBrjrrrOrRrrg_valid_defaultsrorhr0r rrzr) ryrKrr rrrrgrOs rXrzr6@ sTL  )!;HUOO!ME  L%)H)H dnn5567//#  &M I %D  "D&*F? #  ';'; < <!#D/0G0G/Hm_]^ ^ E??%&&E&  &0t%<%<%'%DK  E RWHXXY Y  **4i Z` rWc>[X R5(a URceURU5n[TU]X5nUcU$UR X5n[ R"[U5$rZ) rgr/rrrMvalidate_elementsr[r\rryrrwrOs rXrMContainer.validate sl e-- . .::) ))JJu%E , =L&&s2vvarWc/nURb[UR[5(a[R"[ U5$UH0nURR X5nURU5 M2 URceURU5$![anURXU5 SnAMvSnAff=frZ) r0rgrr[r\rr(rr=rjr)ryrrw validatedrrjs rXr@Container.validate_elements s ;; *T[[#">">66!U# #A $KK))#1  # zz%%%zz)$$  * 35)) *sB  C*CCc>[UR[5(aURRUS5 [TU] X5 grZ)rgr0r>rrrs rXrContainer.class_init s5 dkk9 - - KK " "3 - 3%rWcz[UR[5(aURRU5 ggrZ)rgr0r>rrs rXrContainer.subclass_init s* dkk9 - - KK % %c * .rWc[U[5(d[SU<35e[U5nUR SU5$![a SnN f=f)Load value from a single stringzExpected string, got N)rgrnr=rr3rMryr`r}s rXrContainer.from_string sY!S!!4QE:; ; ?D}}T4(( D s A AAc ^^TRce[U5S:XaUSmTS:XaTR(ag[T5S:a[U4SjTR55(aTR (aTR R S-nOSnTRce[S RUTR-T5[SS 9 TR[T55$[R"TR5nS UR;a TRnO SSU4S jjjnTR[!U5VVs/sH upVU"XeS 9PM snn5$s snnf)zYReturn the value from a list of config strings This is where we parse CLI configuration Nrrrrc3z># UH0upTRU5=(a TRU5v M2 g7frZ)rendswith)rbstartendrs rXrc-Container.from_string_list.. s3#"AJE U#7 37"As8;rrz}--{0}={1} for containers is deprecated in traitlets 5.0. You can pass `--{0} item` ... multiple times to add items to a list.rrcX>[R"[TRU55$rZ)r[r\ritem_from_string)r`rrys rXrV4Container.from_string_list..item_from_string svva!6!6q!9::rW)rrZr`rnrz int | NonerzT | str)rrranyr3rrRrrrirrr  signaturerV parameters enumerate)rys_listrsigrVidxr`rSs` @rXfrom_string_listContainer.from_string_list sJ zz%%% v;! q AF{t1v{s#"&"A"A#  ??"oo66r0r3r[rrzrBrMr@rrrr`rVrVrrs@rXr$r$ s  !E> K#OFE(44ZZ "%"    #               ZZ "%"  !  "               ZZ"                     #(!%# P P P  P  P  P P  P P d   %& + )' RrWr$c^\rSrSr%Sr\r\4rS\ S'S\ S\ R4S U4Sjjjr S SjrSU4S jjrS U4S jjrS rU=r$)r4i zAn instance of a Python list.rr/Nrc B>X@lX0l[TU] "SXS.UD6 g)a9Create a List trait type from a list, set, or tuple. The default value is created by doing ``list(default_value)``, which creates a copy of the ``default_value``. ``trait`` can be specified, which restricts the type of elements in the container to that TraitType. If only one arg is given and it is not a Trait, it is taken as ``default_value``: ``c = List([1, 2, 3])`` Parameters ---------- trait : TraitType [ optional ] the type for restricting the contents of the Container. If unspecified, types are not checked. default_value : SequenceType [ optional ] The default value for the Trait. Must be list/tuple/set, and will be cast to the container type. minlen : Int [ default 0 ] The minimum length of the input list maxlen : Int [ default sys.maxsize ] The maximum length of the input list rKrNrQ_maxlen_minlenrrzryrKrminlenmaxlenrrOs rXrz List.__init__ %D   LuLVLrWczSUR[U5URURU4-n[ U5eNz_The '%s' trait of %s instance must be of length %i <= L <= %i, but a value of %s was specified.rrrnrmr=rs rX length_errorList.length_error!: myy(3-t||UK L mrWc>[U5nX0R:dX0R:aURX5 [TU]X5$rZrrnrmrwrr@ryrrwlengthrOs rXr@List.validate_elements(=U LL F\\$9   c )w(44rWcl>[U[5(a[TU] X/5$[TU] X5$rZrgrnrrBrAs rXrBList.set/0 eS ! !7;sG, ,7;s* *rWrmrn) rKzIt.List[T] | t.Tuple[T] | t.Set[T] | Sentinel | TraitType[T, t.Any] | Nonerz3t.List[T] | t.Tuple[T] | t.Set[T] | Sentinel | Nonerprrqrrrrrrrrwrrrr )rRrSrTrUrr4rrr/rrBsysmaxsizerzrwr@rBrVrrs@rXr4r4 s' EK!\`MVkk $MX$MK$M $M  $M  $M $M$ML5++rWr4c^\rSrSrSr\r\\4r Sr S\ S\ R4S U4SjjjrS SjrSU4SjjrS U4S jjrSS jrS rU=r$)r:i6zAn instance of a Python set.)r1r2z{}Nrc B>X@lX0l[TU] "SXS.UD6 g)a6Create a Set trait type from a list, set, or tuple. The default value is created by doing ``set(default_value)``, which creates a copy of the ``default_value``. ``trait`` can be specified, which restricts the type of elements in the container to that TraitType. If only one arg is given and it is not a Trait, it is taken as ``default_value``: ``c = Set({1, 2, 3})`` Parameters ---------- trait : TraitType [ optional ] the type for restricting the contents of the Container. If unspecified, types are not checked. default_value : SequenceType [ optional ] The default value for the Trait. Must be list/tuple/set, and will be cast to the container type. minlen : Int [ default 0 ] The minimum length of the input list maxlen : Int [ default sys.maxsize ] The maximum length of the input list rkNrQrlros rXrz Set.__init__?rsrWczSUR[U5URURU4-n[ U5erurvrs rXrwSet.length_erroreryrWc>[U5nX0R:dX0R:aURX5 [TU]X5$rZr{r|s rXr@Set.validate_elementslrrWcl>[U[5(a[TU] X15$[TU] X5$rZrrAs rXrBSet.setsrrWc|[[UR5=(d /55nUS:XagSUSS-S-$)Nr1zset(){rr})r}rr!)ry list_reprs rXr~Set.default_value_reprys@ 9 9 ; ArBC  Yq_$s**rWr) rKrrrrprrqrrrrrrr r)rRrSrTrUrrBrrr4r/r3rBrrrzrwr@r~rVrrs@rXr:r:6s& E$-K!3 (kk $M$M$M $M  $M  $M $M$ML5+ ++rWr:ch^\rSrSrSr\r\4rS U4Sjjr S Sjr S Sjr S U4Sjjr S Sjr SrU=r$)r?izAn instance of a Python tuple.c>URS[5n[U5S:Xa#U[La[US5(dUSnSnUcDUR SS5(d-[ SUR RS 3[S S 9 [nU[LaSnONUcSnSUS'OC[X0R5(aU4nO%[S UR RS U35e/Ul UHIn[U[5(a[ S[S S 9 U"5nURRU5 MK UR(aUb U[LaSn[[ U]F"SUR$US.UD6 g)aCreate a tuple from a list, set, or tuple. Create a fixed-type tuple with Traits: ``t = Tuple(Int(), Str(), CStr())`` would be length 3, with Int,Str,CStr for each element. If only one arg is given and it is not a Trait, it is taken as default_value: ``t = Tuple((1, 2, 3))`` Otherwise, ``default_value`` *must* be specified by keyword. Parameters ---------- *traits : TraitTypes [ optional ] the types for restricting the contents of the Tuple. If unspecified, types are not checked. If specified, then each positional argument corresponds to an element of the tuple. Tuples defined with traits are of fixed length. default_value : SequenceType [ optional ] The default value for the Tuple. Must be list/tuple/set, and will be cast to a tuple. If ``traits`` are specified, ``default_value`` must conform to the shape and type they specify. **kwargs Other kwargs passed to `Container` rrrrQNrFr:r;rrr<r=~Traits should be given as instances, not types (for example, `Int()`, not `Int`) Passing types is deprecated in traitlets 4.1.rrg)r5rBrrjrrrOrRrrgr>rorrhrrr$rzr)ryrrrrgrKrOs rXrzTuple.__init__ss< ?I> v;!   :8FSTICVCV"1IMF  L%)H)H dnn5567//#  &M I %D  "D&*F? #  ';'; < <!#D/0G0G/Hm_]^ ^ E%&&E&   LL   & <<]2my6PD i'NdjjtNvNrWcUR(aU[UR5:aU$URURU5$rc)rrrrds rXrVTuple.item_from_strings< ||uDLL(99H||E"..q11rWcUR(dU$[U5[UR5:waCSUR[U5[UR5[ U54-n[ U5e/n[ URU5H(upVURX5nURU5 M* [U5$![ anURXU5 SnAMYSnAff=f)NzTThe '%s' trait of %s instance requires %i elements, but a value of %s was specified.) rrrrr r=rr(rrjr)ryrrwr4rDrKrrjs rXr@Tuple.validate_elementss||L u:T\\* *f99hsmS-> %@PQR Q-  DLL%0HE $OOC+  # 1Y  * 35)) *sC C/C**C/c>URH,n[U[5(dMURUS5 M. [[ U]X5 grZ)rrgr>rrr$ryrrrKrOs rXrTuple.class_inits?\\E%++  d+" i)#4rWczURH+n[U[5(dMURU5 M- grZ)rrgr>rryrrKs rXrTuple.subclass_inits+\\E%++##C("rWrr)rrrrrr)r`rnrrrrr rgr )rRrSrTrUrrrr4r/rzrVr@rrrVrrs@rXr?r?s3( E'KKOZ 2 *5 ))rWr?c^\rSrSrSrSrSrSSS\4SU4SjjjrSSSjjr SU4Sjjr SSjr SU4Sjjr SS jr SS jrSS jrSS jrS rU=r$)r&iaAn instance of a Python dict. One or more traits can be passed to the constructor to validate the keys and/or values of the dict. If you need more detailed validation, you may use a custom validator method. .. versionchanged:: 5.0 Added key_trait for validating dict keys. .. versionchanged:: 5.0 Deprecated ambiguous ``trait``, ``traits`` args in favor of ``value_trait``, ``per_key_traits``. Nc >URSS5nUbUb [S5eUn[S[SS9 URSS5nUbUb [S5eUn[S [SS9 U[La.Ub+[ U5(d[ U[5(aeUnSnUcUb[ U5(aUnSnU[La0nUcSnO@[ U[5(aU4nO'[ U[5(aU4nO[S U-5e[ U5(a2[ U[5(a[S [SS9 U"5nXl OUb[S [U5-5e[ U5(a2[ U[5(a[S [SS9 U"5nX0l OUb[S [U5-5eX l[T U]@"S[US.UD6 g)a0Create a dict trait type from a Python dict. The default value is created by doing ``dict(default_value)``, which creates a copy of the ``default_value``. Parameters ---------- value_trait : TraitType [ optional ] The specified trait type to check and use to restrict the values of the dict. If unspecified, values are not checked. per_key_traits : Dictionary of {keys:trait types} [ optional, keyword-only ] A Python dictionary containing the types that are valid for restricting the values of the dict on a per-key basis. Each value in this dict should be a Trait for validating key_trait : TraitType [ optional, keyword-only ] The type for restricting the keys of the dict. If unspecified, the types of the keys are not checked. default_value : SequenceType [ optional, keyword-only ] The default value for the Dict. Must be dict, tuple, or None, and will be cast to a dict if not None. If any key or value traits are specified, the `default_value` must conform to the constraints. Examples -------- a dict whose values must be text >>> d = Dict(Unicode()) d2['n'] must be an integer d2['s'] must be text >>> d2 = Dict(per_key_traits={"n": Integer(), "s": Unicode()}) d3's keys must be text d3's values must be integers >>> d3 = Dict(value_trait=Integer(), key_trait=Unicode()) rKNzFFound a value for both `value_trait` and its deprecated alias `trait`.zIKeyword `trait` is deprecated in traitlets 5.0, use `value_trait` insteadrrrzJFound a value for both `per_key_traits` and its deprecated alias `traits`.zMKeyword `traits` is deprecated in traitlets 5.0, use `per_key_traits` insteadzdefault value of Dict was %srz-`value_trait` must be a Trait or None, got %sz+`key_trait` must be a Trait or None, got %srrQ)r5rorrrBrjrgr>rrhrh _value_traitr _key_trait_per_key_traitsrrz) ry value_traitper_key_traits key_traitrrrKrrgrOs rXrz Dict.__init__s\ 7D)  &\ K ["  Hd+  )`$N _"  I %+*AK((%k9==== + "  !;''* !% I %M  D  t , ,!#D  } 5 5!#D:]JK K K +t,,E&  *m +   $?)KBXX  I  )T**E&  &K 'O  "IIV_L``a a- 9t$9&9rWc USURS[U5SUR5S[U5S3 -n[ U5e)Nz of the 'rz instance must be r z was specified.)rrr\r r=)ryrelement validatorsider4s rX element_errorDict.element_errorsm $))K >PQZQ_Q_QaPbbst}FuGtHHWX X mrWcN>[TU]X5nUcU$URX5$rZ)rrMr@rAs rXrM Dict.validates- , =L%%c11rWcUR=(d 0nURnURnU(dU(d U(dU$0nUHNnX'nU(aURX5nUR Xu5n U (aU RX5nXU'MP URU5$![a UR XUS5 Nbf=f![a UR XU S5 N[f=f)NKeysValues)rrrr(r=rrr) ryrrwper_key_overriderrrDrractive_value_traits rXr@Dict.validate_elementss//52OO '' [,<L C AD#--c7C"2!5!5c!G !M*44S[UR[5(aURRUS5 [UR[5(aURRUS5 UR b3UR R 5HnURUS5 M [TU] X5 grZ)rgrr>rrrr6rrs rXrDict.class_inits d'' 3 3    ( (d 3 dooy 1 1 OO & &sD 1    +--446  d+7 3%rWcl[UR[5(aURRU5 [UR[5(aURRU5 UR b3UR R 5HnURU5 M ggrZ)rgrr>rrrr6rs rXrDict.subclass_inits d'' 3 3    + +C 0 dooy 1 1 OO ) )# .    +--446##C(7 ,rWc[U[5(d[SU<S[U535e[R "SUR U/55$![a& [U5n[U[5(aUs$ef=f)rKz"from_string expects a string, got z of type dict[K, V]) rgrnrorhr[r\r`r3rerrLs rXrDict.from_strings~!S!!@YtTUwiXY Y 66,(=(=qc(BC C %a(D$%%   s&A,B B c [U5S:XaUSS:XaUR(ag[U5S:XapUSRS5(aWUSRS5(a>[ SUR SUSS UR S 3[ S S 9 [US5$0nUVs/sHo0RU5PM snHnURU5 M U$s snf) zReturn a dict from a list of config strings. This is where we parse CLI configuration. Each item should have the form ``"key=value"``. item parsing is done in :meth:`.item_from_string`. rrrNrrz--rz@ for dict-traits is deprecated in traitlets 5.0. You can pass --z7 ... multiple times to add items to a dict.rr) rrrrPrrrrrVr)ryr]combinedr`rs rXr`Dict.from_string_lists v;! q V 3 v;! q 4 4S 9 9fQi>P>PQT>U>U TYYKq ,""&)),ce"   q * *4:;Fq''*F;A OOA < * ' #          58(+%(" L 1 & #         5>/4%)#  ; 2 -  #      %rWr;c&\rSrSrSrSrSSjrSrg)riUzA casting compiled regular expression trait. Accepts both strings and compiled regular expressions. The resulting attribute will be a compiled regular expression.za regular expressioncr[R"U5$![a URX5 gf=frZ)recompiler3rjr*s rXrMCRegExp.validate]s1 #::e$ $ # JJs " #s 66rQN)rrrwrrzre.Pattern[t.Any] | NonerRrSrTrUrrrMrVrQrWrXrrUs8 'I#rWrzre.Pattern[t.Any]c^\rSrSr%SrSrS\S'SrSSU4Sjjjr\ 4SSjjr \ 4SS jjr SS jr SSS jjr SSS jjrSS jrSSjrSrU=r$)rDida'Use a Enum class as model for the data type description. Note that if no default-value is provided, the first enum-value is used as default-value. .. sourcecode:: python # -- SINCE: Python 3.4 (or install backport: pip install enum34) import enum from traitlets import HasTraits, UseEnum class Color(enum.Enum): red = 1 # -- IMPLICIT: default_value blue = 2 green = 3 class MyEntity(HasTraits): color = UseEnum(Color, default_value=Color.blue) entity = MyEntity(color=Color.red) entity.color = Color.green # USE: Enum-value (preferred) entity.color = "green" # USE: name (as string) entity.color = "Color.green" # USE: scoped-name (as string) entity.color = 3 # USE: number (as int) assert entity.color is Color.green Nzenum.Enum | Nonerz"Trait type adapter to a Enum classc @>[U[R5(d SU-5eURSS5nUc3U(d,[ [ UR R555n[TU]$"SSU0UD6 Xl URS-Ul g)NzREQUIRE: enum.Enum, but was: %rrFrrrQ) rienumr(rnextiter __members__r6rrz enum_classrR name_prefix)ryrrrrrOs rXrzUseEnum.__init__s*dii00`2SV`2``0ZZ e4   j&<&<&C&C&E!FGM ?}??$%..4rWc[U[5(deURRnUR 5HnUR U:XdMUs $ U$)z0Selects enum-value by using its number-constant.)rgrrrr6rw)ryrwrF enum_members enum_items rXselect_by_numberUseEnum.select_by_numbersP%%%%%22 %,,.I%'  /rWc[U[5(deURUR5(aUR URSS5nUR R RX5$)z4Selects enum-value by using its name or scoped-name.rr)rgrnrrreplacerrr)ryrwrFs rXselect_by_nameUseEnum.select_by_names_%%%%%   D,, - -MM$"2"2B:E**..u>>rWch[X R5(aU$[U[5(aURU5nU[LaU$OS[U[ 5(aUR U5nU[LaU$O!UcUR(agUR$URX5 grZ) rgrrrrBrnrrrrj)ryrrwvalue2s rXrMUseEnum.validates e__ - -L s # #**51FY& ' s # #((/FY& ' ]))) 3rWcURRR5nU(aSRSU55$[ [ U55$)rrc3,# UH nSU-v M g7frrQrs rXrc'UseEnum._choices_str..s:'QHqL'r)rrrvrhr}r4)ryrrs rXrUseEnum._choices_strsA//--224 88:':: :W & &rWcpUR(aSU(aSOS-OSnSURU5U3$rrrs rXr UseEnum._inforrWc URSS9$rrrs rXr\ UseEnum.inforrWc URSS9$rrrs rXrUseEnum.info_rstrrW)rrrZ)rrrrrrrr)rwrrFrrr)rwrnrFrrrr rrr)rRrSrTrUrrrrrzrBrrrMrrr\rrVrrs@rXrDrDds~:'+M#*4I?C 5% 56; 5NS 5  5 5=F;D?('; (''rWrDc&\rSrSrSrSrSSjrSrg)r izhA trait which is callable. Notes ----- Classes are callable, as are instances with a __call__() method.z a callablecJ[U5(aU$URX5 grZ)rhrjr*s rXrMCallable.validates E??L JJs "rWrQNr rrQrWrXr r s!I#rWr )r`rrr]r )r[rrr])rprrzt.Iterable[t.Any]rZ)rrrrrzlist[tuple[str, t.Any]])rrrr)rrrr)rprrhrnrr9)rrrr)rprrrE)rrnrr%)rKz'Int[t.Any, t.Any] | Float[t.Any, t.Any]rrrwrrr)r __future__rrrr rrrrtypingr[astr utils.bunchrutils.descriptionsrrr r utils.getargspecr utils.importstringr utils.sentinelrutils.warningsrrrr4rrB frozensetrhrh ClassTypesrtyping_extensionsr__all__rBrNoDefaultSpecifiedr3r=r^rerjrLrsrrrIrGrHrrrrrrrnrrrGenericr>rrr6r7rJrKrMrFr rr)r9rEr%r/r0r"r@r1r,r-r+Optionalr<rCr!r2rr5rr3r*rrYrrr#rrirrrArr8r'rrr(r!r.r$r4r:r?r&r;rrDrQrWrXrs!R#  JJ(+$@@uc9- W ??)< J      * Z 6  ( DLLLL^@E@EF 7 7 t CL CL CL ??/S!AQUU#A A( !Q$A(R !G!GH$6+6+rVL&VLr19,<#.L"B& R 'CJ!781>14=\=9l9>\>"1"Jg -g f #)AqD/ #c@ q!t $c@L]0"1a4(]0@ 8 8.QT  2HQK # qzz!}ajjm; <#0Q&IaeeQUUl #Q&rH )AJJquu%qzz!%%'88 9H V 29>GL 6= )AqD/= @-=3q!t9-=`4 e ? IadO? D-=U1a4[-=` i%) ,#w '155.1# IeUl # B#UIeQUUl+#I i1oI X,#wq!t}iQUU 3,#^38$,zH9QT?HV,#DAJ,#^V39QT?V3r'd1g'B/'Q/'dc cL>+9QVVAY >+BH+)AEE!%%L !H+V|)IaggaeeSj) *|)BN28L !N2b?%1a4?%D #i+QWW5H#5M-NNO #c'iquu %c'L#yCJ/CJ1GGH#rW