a lcS@sdZddlZddlZddlZddlZddlZddlZddlZddlZ ddl m Z ddl m Z mZddlmZddlmZmZmZmZddlmZdd lmZdd lmZeeeefZ e!fZ"gd Z#ed d dZ$edd dZ%e$Z&Gddde'Z(e)dZ*ddZ+eZ,ddZ-ddZ.ddZ/ddZ0ddZ1Gd d!d!Z2dd"d#Z3d$d%Z4Gd&d'd'Z5Gd(d)d)Z6e6Z7Gd*d+d+Z8Gd,d-d-e8Z9Gd.d/d/Z:d0d1Z;Gd2d3d3e!Zd:d;Z?dd?ZAGd@dAdAe8ZBGdBdCdCeBZCGdDdEdEeBZDGdFdGdGeBZEGdHdIdIeZ 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@s eZdZdS)r9N)__name__ __module__ __qualname__rMrMO/var/www/html/django/DPS/env/lib/python3.9/site-packages/traitlets/traitlets.pyr9sr9z[a-zA-Z_][a-zA-Z0-9_]*$cCs|SN isidentifiersrMrMrNrQsrQcCs:tjd}|r|dkrdS|tvr2t|dSdSdS)zZAdd our own checks for too many deprecation warnings. Limit to once per package. ZTRAITLETS_ALL_DEPRECATIONS0TFN)osenvironget_deprecations_shownadd)keyZenv_flagrMrMrN _should_warns   r[c Csdj|j||d}t|D]}||jvr|}q4q|jddd}||f}t|sZdSz$t|phd}t |dpzd} Wn:t t fy} zt |d| t WYd} ~ nd} ~ 00t|t || dS) zShow deprecation warning about a magic method definition. Uses warn_explicit to bind warning to method definition instead of triggering code, which isn't relevant. z?{classname}.{method_name} is deprecated in traitlets 4.1: {msg}) classname method_namemsg.rrNz z (inspection failed) %s)formatrJinspectgetmro__dict__rKsplitr[ getsourcefilegetsourcelinesOSError TypeErrorrDeprecationWarningr) methodclsr]r^Zwarn_msgparent package_namerZfnamelinenoerMrMrN_deprecated_methods" (rqc Cs,z t|WStttfy&|YS0dS)zwSafely evaluate an expression Returns original string if eval fails. Use only where types are ambiguous. N)r NameError SyntaxError ValueErrorrRrMrMrN_safe_literal_evals rucCst|tpt|tot|tS)zHReturns whether the given value is an instance or subclass of TraitType.) isinstancer:type issubclass)trMrMrNis_traitsrzcCsR|tust|tr|gS|r$t|vr*tgS|D]}t|ts.td|q.|SdS)aConvert 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] znames must be strings, not %rN)rrvstrrh)namesnrMrMrNrHs  rHc@s,eZdZddZddZddZddZd S) _SimpleTestcCs ||_dSrOvalueselfrrMrMrN__init__sz_SimpleTest.__init__cCs ||jkSrOr)rtestrMrMrN__call__ sz_SimpleTest.__call__cCs d|jS)Nz||r |||fq ||S)aA safe version of inspect.getmembers that handles missing attributes. This is useful when there are descriptor based attributes that for some reason raise AttributeError even though they exist. This happens in zope.inteface with the __provides__ attribute. )dirgetattrAttributeErrorappendsort)object predicateresultsrZrrMrMrN getmemberss   rcGsf|D]\}t|dks tdt|\}}t|tsBtdt|||vrt|d|qdS)z.Validate arguments for traitlet link functionszKEach linked traitlet must be specified as (HasTraits, 'trait_name'), not %rz%Each object must be HasTraits, not %rz has no trait N)lenrhryrvr,rwtraits)Ztuplestupobj trait_namerMrMrN_validate_link(s   rc@sLeZdZdZdZdddZddZejdd Z d d Z d d Z ddZ dS)rEaRLink 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 FNcCsBt|||||_|_|r |n ddfd\|_|_|dS)NcSs|SrOrMxrMrMrNTzlink.__init__..r)rsourcetarget _transform_transform_invrErrrZ transformrMrMrNrQs z link.__init__c Cszlt|jd|jd|t|jd|jdW|jdj|j|jdd|jdj|j|jddn:|jdj|j|jdd|jdj|j|jdd0dSNrrr|)setattrrrrrrF_update_target_update_sourcerrMrMrNrEXsz link.linkccs$d|_zdVWd|_nd|_0dSNTFupdatingrrMrMrN_busy_updatingdszlink._busy_updatingcCs|jr dS|Zt|jd|jd||jt|jd|jd|jkr^td |Wdn1sr0YdS)NrrzCBroken link {}: the source value changed while updating the target.) rrrrrnewrrr9r`rchangerMrMrNrls  zlink._update_targetcCs|jr dS|Zt|jd|jd||jt|jd|jd|jkr^td |Wdn1sr0YdS)NrrzCBroken link {}: the target value changed while updating the source.) rrrrrrrrr9r`rrMrMrNrws  zlink._update_sourcecCs<|jdj|j|jdd|jdj|j|jdddSr)r unobserverrrrrMrMrNunlinksz link.unlink)N) rJrKrL__doc__rrrE contextlibcontextmanagerrrrrrMrMrMrNrE6s     rEc@sDeZdZdZdZdddZddZejdd Z d d Z d d Z dS)rCaLink 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 FNcCs6|r|ndd|_t|||||_|_|dS)NcSs|SrOrMrrMrMrNrrz+directional_link.__init__..)rrrrrErrMrMrNrs zdirectional_link.__init__c CstzPt|jd|jd|t|jd|jdW|jdj|j|jddn|jdj|j|jdd0dSr)rrrrrrF_updaterrMrMrNrEszdirectional_link.linkccs$d|_zdVWd|_nd|_0dSrrrrMrMrNrszdirectional_link._busy_updatingcCsV|jr dS|0t|jd|jd||jWdn1sH0YdSNrr)rrrrrrrrMrMrNrs zdirectional_link._updatecCs |jdj|j|jdddSr)rrrrrMrMrNrszdirectional_link.unlink)N) rJrKrLrrrrErrrrrrMrMrMrNrCs   rCc@sVeZdZUdZdZejeed<dZ ejej ej ed<ddZ ddZ d d ZdS) raBase descriptor class Notes ----- This implements Python's descriptor protocol. This class is the base class for all such descriptors. The only magic we use is a custom metaclass for the main :class:`HasTraits` class that does the following: 1. Sets the :attr:`name` attribute of every :class:`BaseDescriptor` instance in the class dict to the name of the attribute. 2. Sets the :attr:`this_class` attribute of every :class:`BaseDescriptor` instance in the class dict to the *class* that declared the trait. This is used by the :class:`This` trait to allow subclasses to accept superclasses for :class:`This` values. Nname this_classcCs||_||_dS)aEPart of the initialization which may depend on the underlying HasDescriptors class. It is typically overloaded for specific types. This method is called by :meth:`MetaHasDescriptors.__init__` passing the class (`cls`) and `name` under which the descriptor has been assigned. N)rrrrkrrMrMrN class_inits zBaseDescriptor.class_initcCsdSrOrM)rrkrMrMrN subclass_initszBaseDescriptor.subclass_initcCsdS)aLPart of the initialization which may depend on the underlying HasDescriptors instance. It is typically overloaded for specific types. This method is called by :meth:`HasTraits.__new__` and in the :meth:`BaseDescriptor.instance_init` method of descriptors holding other descriptors. NrMrrrMrMrN instance_inits zBaseDescriptor.instance_init)rJrKrLrrryOptionalr{__annotations__rr<rrrrrMrMrMrNrs  rc@seZdZUdZiZejeejfe d<dZ dZ dZ e Zejeje d<e ddddfddZd d Zd+d d Zd dZddZd,ddZd-ddZddZddZddZddZddZdd Zd.d!d"Zd/d#d$Zd%d&Zd'd(Z d)d*Z!dS)0r:z!A base class for all trait types.metadataF any value default_valueNc Ks>|tur||_|r||_|dur&||_|dur2|nd|_t|dkrd}t}|dus^J|jj dkr|d7}|j }|dus^Jq^|j dpd} | ddd} td| gt|} t| rtd |ft|d t|jdkr|j|_|j|n||_n |j|_|dur&||jd <|dur:||jd <dS) aDeclare 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. Extra metadata can be associated with the traitlet using the .tag() convenience method or by using the traitlet instance's .metadata dictionary. NrrrrJr_z metadata-tagzmetadata %s 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)r>r allow_none read_onlyrrra currentframef_codeco_namef_back f_globalsrWrdtuplesortedr[rrircopyupdate) rrrrrrkwargsrfmodpkgrZrMrMrNrsF       zTraitType.__init__cCs|jr|dkrdS|S)a Get 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 NoneNrrrSrMrMrN from_stringMs zTraitType.from_stringcCs,|jtur|jSt|dr"|S|jSdS)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_defaultN)rr>hasattrrrrMrMrNrB]s   zTraitType.defaultcCstdtdd|jS)zmDEPRECATED: 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)rrirrrMrMrNget_default_valuems zTraitType.get_default_valuecCs,tdtdd|||j}||j|j<|S)zrricross_validation_lockr_notify_observersr Exceptionr9)rrrkrrBrMrMrNrWs2  *  z TraitType.getcCs|dur |S|||SdS)aMGet the value of the trait by self.name for the instance. Default values are instantiated when :meth:`HasTraits.__new__` is called. Thus by the time this method gets called either the default value or a user defined value (they called :meth:`__set__`) is in the :class:`HasTraits` instance. N)rW)rrrkrMrMrN__get__szTraitType.__get__cCs|||}z|j|j}Wnty4|j}Yn0||j|j<zt||k}Wntyhd}Yn0|dur||j||dS)NFT)rrrrrboolr _notify_trait)rrr new_value old_valueZsilentrMrMrNsets      z TraitType.setcCs&|jrtd|jn |||dS)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)rr9rrrrMrMrN__set__szTraitType.__set__cCsB|dur|jr|St|dr(|||}|jdur>|||}|S)NrIF)rrrI_cross_validation_lock_cross_validaterrMrMrNrs    zTraitType._validatecCsr|j|jvr0t|||d}|j|j||}n>t|d|jrnd|j}t||}t||j|d|||}|S)N)traitrr _%s_validate use @validate decorator instead.)r_trait_validatorsrrrrq __class__)rrrZproposal meth_nameZcross_validaterMrMrNrs    zTraitType._cross_validatecCs*t|trt|g|jSt||gSdSrOrvr? trait_typesrotherrMrMrN__or__s zTraitType.__or__cCs|jSrO) info_textrrMrMrNinfoszTraitType.infoc Cs|dur|j|f7_|jdurddd|jddD}|durzd|jtd|||jdtd |jd ff|_n(d |j||jdtd |jd ff|_|nl|jdurt||p||nL|durd |jt||td |}nd |j|td |}t|dS)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 infered from this trait's ``info`` method. N of css|]}td|VqdS)aN)r ).0ryrMrMrN rz"TraitType.error..rzDThe '%s' trait of %s instance contains %s which expected %s, not %s.ZanrZtherz5The '%s' trait contains %s which expected %s, not %s.z2The '{}' trait of {} instance expected {}, not {}.z#The '{}' trait expected {}, not {}.)argsrjoinr r9rr`r)rrrerrorrchainrprMrMrNrsL    zTraitType.errorcCs2|dkrd}nd}td|tdd|j||S)znDEPRECATED: Get a metadata value. Use .metadata[key] or .metadata.get(key, default) instead. rz3use 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)rrirrW)rrZrBr^rMrMrN get_metadata=s zTraitType.get_metadatacCs2|dkrd}nd}td|tdd||j|<dS)z[DEPRECATED: Set a metadata key/value. Use .metadata[key] = value instead. rz;use the instance .help string directly, like x.help = valuezLuse the instance .metadata dictionary directly, like x.metadata[key] = valuerrrN)rrir)rrZrr^rMrMrN set_metadataIs zTraitType.set_metadatacKs<t|hd}|r,td|tdd|j||S)aSets metadata and returns self. This allows convenient metadata tagging when initializing the trait, such as: Examples -------- >>> Int(0).tag(config=True, sync=True) >rrrrzcThe following attributes are set in using `tag`, but seem to be constructor keywords arguments: %s rr)rkeys intersectionr UserWarningrr)rrZmaybe_constructor_keywordsrMrMrNtagUs  z TraitType.tagcCs t|jSrO)reprrrrMrMrNdefault_value_reprnszTraitType.default_value_repr)N)N)N)NN)N)"rJrKrLrrryr"r{rrrrrr>rrrrrBrrrWrrrrrrrrrrr r rMrMrMrNr:s:  ?      N  r:c@s(eZdZdZddZddZddZdS) _CallbackWrapperzAn object adapting a on_trait_change callback into an observe callback. The comparison operator __eq__ is implemented to enable removal of wrapped callbacks. cCsH||_t|jtjrdnd}tt|d||_|jdkrDtddS)Nrz1a trait changed callback must have 0-4 arguments.)cbrvtypes MethodTyperr nargsr9)rroffsetrMrMrNr~s  z_CallbackWrapper.__init__cCs$t|tr|j|jkS|j|kSdSrO)rvr rrrMrMrN__eq__s  z_CallbackWrapper.__eq__cCs|jdkr|nv|jdkr,||jn^|jdkrH||j|jnB|jdkrh||j|j|jn"|jdkr||j|j|j|jdS)Nrrrr)rrrroldrrrMrMrNrs      z_CallbackWrapper.__call__N)rJrKrLrrrrrMrMrMrNr wsr cCst|tr|St|SdSrO)rvr )rrMrMrN_callback_wrappers rcs4eZdZdZfddZfddZddZZS)r2zA metaclass for HasDescriptors. This metaclass makes sure that any TraitType class attributes are instantiated and sets their name attribute. csP|D]4\}}t|rt|trtdtdd|||<qt||||S)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) itemsraisclassrxr:rrisuper__new__)mclsrbases classdictkvrrMrNrs zMetaHasDescriptors.__new__cst|||||dS)z-Finish initializing the HasDescriptors class.N)rr setup_class)rkrrr r#rMrNrszMetaHasDescriptors.__init__cCsR|D]\}}t|tr|||qt|D]\}}t|tr0||q0dS)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)rrvrrrr)rkr r!r"_rMrMrNr$s   zMetaHasDescriptors.setup_class)rJrKrLrrrr$ __classcell__rMrMr#rNr2s  r2cs eZdZdZfddZZS)r3zA metaclass for HasTraits.csi|_t|dSrO)_trait_default_generatorsrr$)rkr r#rMrNr$szMetaHasTraits.setup_class)rJrKrLrr$r&rMrMr#rNr3sr3rrwcGs@|s td|D]"}|turt|tstd|qt||dS)aA 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()rhrrvr{r5)rwr|rrMrMrNrFs rFcsttffdd }|S)aZBackward-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. csFt|tr|}n,|jj}td||fttd||||d}||S)NzSA parent of %s._%s_changed has adopted the new (traitlets 4.1) @observe(change) APIr)rwrrrr)rvdictrrJrrir)rZchange_or_namerrrclsnamefuncrMrNcompatible_observers" z+observe_compat..compatible_observer)r>)r,r-rMr+rNrGsrGcGs<|s td|D]"}|turt|tstd|qt|S)aA 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)rhrrvr{rA)r|rrMrMrNrIs rIcCst|tstd|t|S)a,A 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)rvr{rhr!)rrMrMrNrB;s$  rBc@s&eZdZddZddZdddZdS) r%cCs ||_|SrOr+)rr,rMrMrN _init_calleszEventHandler._init_callcOs.t|dr|j|i|S|j|i|SdS)zCPass `*args` and `**kwargs` to the handler's function if it exists.r,N)rr,r.)rrrrMrMrNris zEventHandler.__call__NcCs|dur |St|j|SrO)rrr,)rinstrkrMrMrNrpszEventHandler.__get__)N)rJrKrLr.rrrMrMrMrNr%dsr%c@seZdZddZddZdS)r5cCs||_||_dSrO) trait_namesrw)rr|rwrMrMrNrwszObserveHandler.__init__cCs|j||j|jddS)Nr()rFr0rwrr/rMrMrNr{szObserveHandler.instance_initNrJrKrLrrrMrMrMrNr5vsr5c@seZdZddZddZdS)rAcCs ||_dSrOr0)rr|rMrMrNrszValidateHandler.__init__cCs|||jdSrO)_register_validatorr0r1rMrMrNrszValidateHandler.instance_initNr2rMrMrMrNrAsrAcs$eZdZddZfddZZS)r!cCs ||_dSrO)rrrrMrMrNrszDefaultHandler.__init__cst||||j|j<dSrO)rrr'rrr#rMrNrszDefaultHandler.class_init)rJrKrLrrr&rMrMr#rNr!sr!cs8eZdZdZejejejdfdd ZddZZS)r+z5The base class for all classes that have descriptors.)rrreturncs^|d}|dd}tt|j}|tjur4||}n||g|Ri|}|j|i||Sr)rr+rrsetup_instance)rrrkZnew_methr/r#rMrNrs    zHasDescriptors.__new__c Osh|d}|dd}d|_|j}t|D]:}zt||}WntyLYq(0t|tr(||q(dS)zD This is called **before** self.__init__ is called. rrNF)rrrrrrvrr)rrrrkrZrrMrMrNr7s    zHasDescriptors.setup_instance) rJrKrLrryrrr7r&rMrMr#rNr+sr+) metaclasscseZdZUejeejfed<ejeejfed<ejeejfed<eed<fddZ fddZ d d Z d d Z e ejd dZejddZddZddZddZddZddZdFddZedfd d!Zedfd"d#Zefd$d%Zd&d'Zd(d)Zd*d+Zed,d-Z ed.d/Z!efd0d1Z"d2d3Z#d4d5Z$d6d7Z%d8d9Z&d:d;Z'dd?Z)dGd@dAZ*efdBdCZ+edHdDdEZ,Z-S)Ir,r_trait_notifiersrrcsF|d}|dd}i|_i|_i|_d|_tt|j|i|dS)NrrF)rr9rrrr,r7)rrrr#rMrNr7s zHasTraits.setup_instancec s|}i}|B|D](\}}||r:t|||q|||<qWdn1sX0Yztj|i|Wnty}zhdd|D}|D]\} } || d| qd|} t dj | |j j |dt ddWYd}~n d}~00dS) NcSsg|] }t|qSrM)r )rargrMrMrN rz&HasTraits.__init__..=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_sr\rrr)hold_trait_notificationsr has_traitrrrrhrrrr`rrJri) rrrZ super_argsZ super_kwargsrZrrpZ arg_s_listr!r"r=r#rMrNrs.  ( zHasTraits.__init__cCs4|j}i|d<i|d<|j|d<d|d<|S)Nr9rrFr)rcrr)rdrMrMrN __getstate__s  zHasTraits.__getstate__c CsX||_|j}t|D]:}zt||}Wnty<Yq0t|tr||qdSrO) rrcrrrrrvr%r)rstaterkrZrrMrMrN __setstate__s    zHasTraits.__setstate__ccs4|jrdVdSzd|_dVWd|_nd|_0dS)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. NTF)rrrMrMrNrs zHasTraits.cross_validation_lockc #sz|jrdVdSiddfdd}zzR||_d|_dVtD].}t|j|}||t||}|||qNWnty}ztdd|_ D]L\}}|ddd D]4}|j d kr|j t ur|||j q|j |qqi|WYd}~n d}~00Wd |_|`D]}|D]}||q,q$n2d |_|`D]}|D]}||q^qV0dS) aHContext 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. NcSsJ|dur|gS|dddkr8|jdkr8|j|dd<n |||SdS)z5Merges the provided change with the last if possible.Nrrwrr)rwrr)Z past_changesrrMrMrNcompress+s  z4HasTraits.hold_trait_notifications..compresscs|j}|||<dSrO)rrW)rrcacherDrMrNhold7sz0HasTraits.hold_trait_notifications..holdTcSsdSrOrMrrMrMrNrHrz4HasTraits.hold_trait_notifications..rrF)r notify_changelistrrrr set_traitr9rrwrr>rpopvalues)rrGrrrrpchangesrrMrErNr>sD        z"HasTraits.hold_trait_notificationsc Cs|t||||dddS)Nr)rrrrrw)rHr)rrrrrMrMrNr]szHasTraits._notify_traitcCs ||S)z"Notify observers of a change event)rrrMrMrNrHhszHasTraits.notify_changec CsDt|tst|}|j|j}}g}||j|i|g||j|itg||jti|g||jtitgd|}|jdkrt||rt |j |}t|t st ||j |dt ||}||vr| t||D]D}t|tr|j}n$t|tr6|jdur6t ||j}||qdS)zNotify observers of any eventz _%s_changedrz$use @observe and @unobserve instead.N)rvrrrwextendr9rWrrrrr5rqrrr rr%) reventrrwZ callables magic_name class_valuercrMrMrNrls>      zHasTraits._notify_observerscCsd||jvrg}||i|j|<n0||j|vr@g}||j||<n|j||}||vr`||dSrO)r9r)rhandlerrrwZnlistrMrMrN_add_notifierss zHasTraits._add_notifierscCsFz.|dur|j||=n|j|||Wnty@Yn0dSrO)r9remover)rrSrrwrMrMrN_remove_notifierss  zHasTraits._remove_notifiersNFcCsHtdtdd|durt}|r2|jt||dn|jt||ddS)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)rrirrrrF)rrSrrUrMrMrNon_trait_changeszHasTraits.on_trait_changercCs$t|}|D]}||||q dS)a Setup 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)rHrTrrSr|rwr}rMrMrNrFszHasTraits.observecCs$t|}|D]}||||q dS)aRemove 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)rHrVrXrMrMrNrszHasTraits.unobservecCs4|turi|_n z |j|=Wnty.Yn0dS)zRemove trait change handlers of any type for the specified name. If name is not specified, removes all trait notifiers.N)rr9rr5rMrMrN unobserve_all s   zHasTraits.unobserve_allcCsZ|D]<}d|}t||rt|j|}t|tst||j|dq|D]}||j|<qFdS)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 rrN)rrrrvrArqr)rrSr|rrPrQrMrMrNr4s   zHasTraits._register_validatorcKs\|j}d|ji}t|dr$|j|d<||t|j|f||_|D]}||qHdS)z;Dynamically add trait attributes to the HasTraits instance.rKrLN) rrKrrLrrwrJrLr)rrrkattrsrrMrMrN add_traits7s     zHasTraits.add_traitscCs>|j}||s(td|jd|nt||||dS)z>Forcibly sets trait attribute, including read-only attributes.Class  does not have a trait named N)rr?r9rJrr)rrrrkrMrMrNrJCs zHasTraits.set_traitcKst|jfi|S)zGet a list of all the names of this class' traits. This method is just like the :meth:`trait_names` method, but is unbound. )rI class_traitsrkrrMrMrNclass_trait_namesKszHasTraits.class_trait_namescKstddt|D}t|dkr&|Si}|D]H\}}|D].\}}t|sZt|}||j|dsBq2qB|||<q2|S)aGet 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. cSsg|]}t|dtr|qSrrvr:rZmembrMrMrNr;erz*HasTraits.class_traits..rN)r)rrrcallabler~rrW)rkrrresultrr meta_name meta_evalrMrMrNr^Ts  zHasTraits.class_traitsc s,t||fdd|jfi|DS)zGet a dict of all the traitlets defined on this class, not a parent. Works like `class_traits`, except for excluding traits from parents. cs&i|]\}}t|d|ur||qSrOr)rr}rysuprMrN }sz.HasTraits.class_own_traits..)rr^rr_r#rirNclass_own_traitsvs  zHasTraits.class_own_traitscCstt|j|dtS)z?Returns True if the object has a trait with the specified name.N)rvrrr:r5rMrMrNr?szHasTraits.has_traitcCs ||jvS)a'Returns 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") )rr5rMrMrNtrait_has_valueszHasTraits.trait_has_valuec sfddjfi|DS)aA ``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``. csi|]}|t|qSrMrh)rrrrMrNrkrz*HasTraits.trait_values..r3rrrMrrN trait_valuesszHasTraits.trait_valuescCsd|}||jvrt||S|j}t||}t|ts:J|}z|d||jd}WntypYn0|D]<}||jvrt||S||j divrv|j |Sqv|j S)zReturn default generator for a given trait Walk the MRO to resolve the correct default generator according to inheritance. z _%s_defaultNrr') rcrrrvr:mroindexrrtrWr'rB)rrr]rkrrprRrMrMrN_get_trait_default_generators"     z&HasTraits._get_trait_default_generatorcOs|D]*}||std|dt|jdqt|dkrZt|dkrZ||d|S|jfi|}||i}|D]}|||||<q||S)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 ' instancesrr)r?r9rwrJrrrr0rN)rr|rr}r0defaultsrMrMrNrs  zHasTraits.trait_defaultscKst|jfi|S)z2Get a list of all the names of this class' traits.)rIrrnrMrMrNr0szHasTraits.trait_namescKstddt|jD}t|dkr(|Si}|D]H\}}|D].\}}t|s\t|}||j|dsDq4qD|||<q4|S)aGet 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. cSsg|]}t|dtr|qSrarbrcrMrMrNr;rz$HasTraits.traits..rN) r)rrrrrdr~rrW)rrrrerrrfrgrMrMrNrs  zHasTraits.traitscCszt|j|}Wn*ty:td|jjd|Yn0d|d}t||rr|t||vrrt||||S|j||SdS)z%Get metadata values for trait by key.r\r]r% _metadataN)rrrr9rJrrWr)rZ traitnamerZrBr metadata_namerMrMrNtrait_metadatas   zHasTraits.trait_metadatacs&t||fdd||DS)zGet a dict of all event handlers defined on this class, not a parent. Works like ``event_handlers``, except for excluding traits from parents. cs&i|]\}}t|d|ur||qSrOrh)rr}rprirMrNrksz4HasTraits.class_own_trait_events..)reventsr)rkrr#rirNclass_own_trait_eventss   z HasTraits.class_own_trait_eventscCsni}t|D]\\}}t|tr |dur0|||<q ||jvrD|||<q t|dr |jfi|jr |||<q |S)aGet 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. Ntags)rrvr%r0rrz)rkrrxr!r"rMrMrN trait_events"s      zHasTraits.trait_events)NNF)N)N).rJrKrLryr"r{rrrr7rrArCpropertyrrrr>rrHrrTrVrWrrFrrYr4r[rJ classmethodr`r^rlr?rmrorrrr0rrwryr{r&rMrMr#rNr,sV  !   @ -  ( "   ! !  r,c@seZdZdZddZdS)rze A trait with error reporting and string -> type resolution for Type, Instance and This. cCst|S)zM Resolve a string supplied for a type into an actual object. r )rstringrMrMrN_resolve_stringLsz#ClassBasedTraitType._resolve_stringNrJrKrLrrrMrMrMrNrFsrcsReZdZdZedffdd ZddZddZfd d Zd d Z d dZ Z S)r<zrrarrvr{r9klassrr)rrrrZnew_default_valuer#rMrNrVsz Type.__init__cCszt|tr@z||}Wn&ty>td|j||fYn0zt||jrT|WSWntyhYn0| ||dS)z4Validates that the value is a valid object instance.zJThe '%s' trait of %s instance must be a type, but %r could not be importedN) rvr{r ImportErrorr9rrxrrrrrMrMrNrIs       z Type.validatecCsBt|jtr|j}n|jjd|jj}d|}|jr>|dS|S)#Returns a description of the trait.r_za subclass of '%s' or None)rvrr{rKrJr)rrrerMrMrNrs z Type.infocs|t|dSrO_resolve_classesrrrr#rMrNrszType.instance_initcCs8t|jtr||j|_t|jtr4||j|_dSrO)rvrr{rrrrMrMrNrs  zType._resolve_classescCs>|j}|dusJt|tr$t|St|jd|jSdS)Nr_)rrvr{r rKrJrrMrMrNr s   zType.default_value_repr) rJrKrLrr>rrIrrrr r&rMrMr#rNr<Ss, r<csbeZdZdZdZdfdd ZddZddZfd d Zd d Z d dZ ddZ ddZ Z S)r-zA 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 Nc s|dur|j}|dur2t|s*t|tr2||_n td||durXt|tsXtd|durrt|tsrtd||_||_ t j fi|dS)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.) rrarrvr{r9r)r default_argsdefault_kwargsrr)rrrkwrr#rMrNrs zInstance.__init__cCs.|jdusJt||jr|S|||dSrO)rrvrrrMrMrNrIs zInstance.validatecCs6t|jtrt|j}n td|j}|jr2|d7}|S)Nrr)rvrr{rr r)rrerMrMrNrs    z Instance.infocs|t|dSrOrrr#rMrNrszInstance.instance_initcCst|jtr||j|_dSrO)rvrr{rrrMrMrNrs zInstance._resolve_classescCsB|jdur|jdurdS|jdus&J|j|jp2di|jp.N)rIrrrrr)rrrr#rMrNrKs zUnion.__init__Ncs4t|}|jD]}|tur*||}qq0q|SrO)rrBrr>)rrrBrr#rMrNrBks    z Union.defaultcs.t|jD]}||dq t||dSrO)reversedrrr)rrkr trait_typer#rMrNrtszUnion.class_initcs*t|jD]}||q t|dSrO)rrrr)rrrr#rMrNrys zUnion.instance_initc Cs|jz|jD]b}zF|||}|jdurBt|d|jd|j|WWdStynYqYq0qWdn1s0Y|||dS)Nr%ru)rrrrrrr9r)rrrrr"rMrMrNrI~s    *zUnion.validatecCs.t|trt|j|jSt|j|gSdSrOrrrMrMrNrs z Union.__or__c sP|jD]<}z||}|d|WSttfy@YqYq0qt|SrO)rrrIr9rtr)rrSrr"r#rMrNrs   zUnion.from_string)N) rJrKrLrrrBrrrIrrr&rMrMr#rNr?Hs    r?c@s.eZdZUdZdZejejed<dZ dZ dS)rzA trait which allows any value.NrTr) rJrKrLrrryrrrrrrMrMrMrNrs rcCsh|jdur2||jkr2tdj|jt|||jd|jdurd||jkrdtdj|jt|||jd|S)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. Nz}The value of the '{name}' trait of {klass} instance should not be less than {min_bound}, but a value of {value} was specified)rrrZ min_boundzThe value of the '{name}' trait of {klass} instance should not be greater than {max_bound}, but a value of {value} was specified)rrrZ max_bound)minr9r`rrmax)rrrrMrMrN_validate_boundssrcs>eZdZdZdZdZedffdd ZddZd d Z Z S) r.z An int trait.rzan intFc s8|dd|_|dd|_tjf||d|dS)Nrrrr)rKrrrrrrrrr#rMrNrsz Int.__init__cCs"t|ts|||t|||SrO)rvintrrrrMrMrNrIs  z Int.validatecCs|jr|dkrdSt|SNr)rrrrMrMrNrszInt.from_string rJrKrLrrrr>rrIrr&rMrMr#rNr.s r.c@seZdZdZddZdS)rz#A casting version of the int trait.cCs8z t|}Wnty*|||Yn0t|||SrO)rrrrrrMrMrNrIs   z CInt.validateNrJrKrLrrIrMrMrMrNrsrcs>eZdZdZdZdZedffdd ZddZd d Z Z S) r&zA float trait.gza floatFc sB|dtd |_|dtd|_tjf||d|dS)Nrinfrr)rKfloatrrrrrr#rMrNrszFloat.__init__cCs4t|trt|}t|ts(|||t|||SrO)rvrrrrrrMrMrNrIs    zFloat.validatecCs|jr|dkrdSt|Sr)rrrrMrMrNrszFloat.from_stringrrMrMr#rNr&s r&c@seZdZdZddZdS)rz%A casting version of the float trait.cCs8z t|}Wnty*|||Yn0t|||SrO)rrrrrrMrMrNrI s   zCFloat.validateNrrMrMrMrNrsrc@s(eZdZdZdZdZddZddZdS) rzA trait for complex numbers.yza complex numbercCs4t|tr|St|ttfr$t|S|||dSrO)rvcomplexrrrrrMrMrNrI s  zComplex.validatecCs|jr|dkrdSt|Sr)rrrrMrMrNr szComplex.from_stringNrJrKrLrrrrIrrMrMrMrNr s rc@seZdZdZddZdS)rz.A casting version of the complex number trait.cCs.z t|WSty(|||Yn0dSrO)rrrrrMrMrNrI s  zCComplex.validateNrrMrMrMrNr src@s(eZdZdZdZdZddZddZdS) rzA trait for byte strings.rza bytes objectcCst|tr|S|||dSrO)rvbytesrrrMrMrNrI0 s zBytes.validatecCsz|jr|dkrdSt|dkrpdD]L}|ddd|kr"|d|kr"|}|dd}td||ftqpq"|dS) Nrr"rsrbrzZSupporting extra quotes around Bytes is deprecated in traitlets 5.0. Use %r instead of %r.utf8)rrr FutureWarningencode)rrSquoteold_srMrMrNr5 s " zBytes.from_stringNrrMrMrMrNr* s rc@seZdZdZddZdS)rz+A casting version of the byte string trait.cCs.z t|WSty(|||Yn0dSrO)rrrrrMrMrNrIJ s  zCBytes.validateNrrMrMrMrNrG src@s(eZdZdZdZdZddZddZdS) r=zA trait for unicode strings.rza unicode stringc Csft|tr|St|trVz|ddWStyTd}t|||jt|Yn0| ||dS)Nasciistrictz=5.)rrUpath expanduserrrr)rrSrRrrMrMrNrb s    zUnicode.from_stringNrrMrMrMrNr=Q s  r=c@seZdZdZddZdS)rz'A casting version of the unicode trait.cCs.z t|WSty(|||Yn0dSrO)r{rrrrMrMrNrIw s  zCUnicode.validateNrrMrMrMrNrt src@s0eZdZdZdZeddZddZddZd S) r4z{A 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 PythoncCs|SrOrM)r%rSrMrMrNr rzObjectName.cCs2|||}t|tr"t|r"|S|||dSrO) coerce_strrvr{rQrrrMrMrNrI s zObjectName.validatecCs|jr|dkrdS|SrrrrMrMrNr szObjectName.from_stringN) rJrKrLrr staticmethodrrIrrMrMrMrNr4~ s  r4c@seZdZdZddZdS)r#zFA string holding a valid dotted object name in Python, such as A.b3._ccCsB|||}t|tr2tdd|dDr2|S|||dS)Ncss|]}t|VqdSrOrP)rrrMrMrNr rz,DottedObjectName.validate..r_)rrvr{allrdrrrMrMrNrI s "zDottedObjectName.validateNrrMrMrMrNr# sr#c@s(eZdZdZdZdZddZddZdS) rzA boolean (True, False) trait.Fz a booleancCs@t|tr|St|tr0|dkr$dS|dkr0dS|||dS)NrTrF)rvrrrrrMrMrNrI s  z Bool.validatecCs>|jr|dkrdS|}|dvr&dS|dvr2dStddS)Nr>1trueT>falserTFz%r is not 1, 0, true, or false)rlowerrtrrMrMrNr szBool.from_stringNrrMrMrMrNr s  rc@seZdZdZddZdS)rz'A casting version of the boolean trait.cCs.z t|WSty(|||Yn0dSrO)rrrrrMrMrNrI s  zCBool.validateNrrMrMrMrNr srcsXeZdZdZeffdd ZddZdddZdd d Zd d Z d dZ ddZ Z S)r$z0An enum whose value must be in a given sequence.c s6||_|ddr|turd}tj|fi|dS)NrF)rLrWr>rrrrLrrr#rMrNr sz Enum.__init__cCs||jvr|S|||dSrO)rLrrrMrMrNrI s z Enum.validateFcCs0|j}|r ddd|D}n tt|}|S)6Returns a description of the trait choices (not none).|css|]}d|VqdSz``%r``NrMrrrMrMrNr rz$Enum._choices_str..)rLrr rIras_rstchoicesrMrMrN _choices_str s  zEnum._choices_strcCs.|jrd|rdndnd}d|||Sr or %s`None`rrany of rrrrnonerMrMrN_info sz Enum._infocCs |jddSNFrrrrMrMrNr sz Enum.infocCs |jddSNTrrrrMrMrNinfo_rst sz Enum.info_rstcCs.z|d|WSty(t|YS0dSrO)rIr9rurrMrMrNr s zEnum.from_string)F)F) rJrKrLrr>rrIrrrrrr&rMrMr#rNr$ s r$csFeZdZdZeffdd ZddZd ddZd d Zd d Z Z S)rz4An enum of strings where the case should be ignored.c stj|fd|i|dSNrrrr#rMrNr szCaselessStrEnum.__init__cCsJt|ts||||jD]}||kr|Sq|||dSrO)rvr{rrLr)rrrr"rMrMrNrI s     zCaselessStrEnum.validateFcCs0|jrd|rdndnd}d||d|S)rrrrrrz (case-insensitive)rrrMrMrNr szCaselessStrEnum._infocCs |jddSrrrrMrMrNr szCaselessStrEnum.infocCs |jddSrrrrMrMrNr szCaselessStrEnum.info_rst)F) rJrKrLrr>rrIrrrr&rMrMr#rNr s  rcsReZdZdZdZdZeddffdd ZddZd ddZ d d Z d d Z Z S)r*zEAn case-ignoring enum matching choices by unique prefixes/substrings.Fc s(||_||_tj|fd|i|dSr)case_sensitivesubstring_matchingrr)rrLrrrrr#rMrNr szFuzzyEnum.__init__cstts|||jr$ddndd|j}|r>ddndd|j}fdd|D}t|dkrt||D]\}}|r|Sq||dS) NcSs|SrOrMrRrMrMrNr rz$FuzzyEnum.validate..cSs|SrO)rrrMrMrNr rcSs||vSrOrMr"rRrMrMrNr# rcSs ||SrO) startswithrrMrMrNr% rcsg|]}|qSrMrM)rrRZ conv_func match_funcrrMrNr;) rz&FuzzyEnum.validate..r)rvr{rrrrLsumzip)rrrrrmatchesr"mrMrrNrI s      zFuzzyEnum.validatecCsV|jrd|rdndnd}|jr$dnd}|jr2dnd}d |d |d |||S) rrrrrZ sensitiveZ insensitiveZ substringprefixz any case- r)rrrr)rrrcasesubstrrMrMrNr1 szFuzzyEnum._infocCs |jddSrrrrMrMrNr8 szFuzzyEnum.infocCs |jddSrrrrMrMrNr; szFuzzyEnum.info_rst)F) rJrKrLrrrr>rrIrrrr&rMrMr#rNr* s  r*cseZdZUdZdZejejeej ej fe d<dZ ej e d<e ZdZdZej e d<deffdd Zfd d Zd d ZfddZfddZddZddZdddZZS)r z\An instance of a container (list, set, etc.) To be subclassed by overriding klass. NrrM _cast_types)[]()_literal_from_string_pairsc s|dur |tur t|s |}d}|durR|ddsRtd|jjdtddt}|tur`d}nB|durvd}d|d <n,t||jr|f}nt d |jjd |t|rt|t rtd td dt|t r|n||_ n|durt dt |t jf|j|d|dS)aCreate 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=UndefinedrrrMrdefault value of  was rrz'`trait` must be a Trait or None, got %srr)r>rzrWrrrJrirv_valid_defaultsrhrw_traitr rrr)rrrrrr#rMrNrK s:   zContainer.__init__csNt||jr$|jdusJ||}t||}|dur>|S|||}|SrO)rvrrrrIvalidate_elementsrr#rMrNrI s   zContainer.validatec Csg}|jdust|jtr|S|D]T}z|j||}Wn2tyj}z||||WYd}~q"d}~00||q"|jdusJ||SrO)rrvrrr9rrr)rrr validatedr"rrMrMrNr s$ zContainer.validate_elementscs,t|jtr|j|dt||dSrO)rvrr:rrrr#rMrNr s zContainer.class_initcs(t|jtr|j|t|dSrO)rvrr:rrrr#rMrNr s  zContainer.instance_initcCsHt|tstd|z t|}Wnty:d}Yn0|d|S)Load value from a single stringzExpected string, got N)rvr{r9rrrIrrSrrMrMrNr s    zContainer.from_stringcsjdusJt|dkr|ddkr4jr4dStdkrtfddjDrjrljjd}nd }jdus~Jtd |jt t St j}d |jvrˆjndfd d fddt|DS)ziReturn the value from a list of config strings This is where we parse CLI configuration Nrrrrc3s&|]\}}|o|VqdSrO)rendswith)rstartend)rrMrNr sz-Container.from_string_list..r_rz}--{0}={1} for containers is deprecated in traitlets 5.0. You can pass `--{0} item` ... multiple times to add items to a list.rqcs |SrOitem_from_string)rSrqrrMrNr rz,Container.from_string_list..csg|]\}}||dqS))rqrM)ridxrSrrMrNr; rz.Container.from_string_list..)N)rrranyrrrJrrr`rrra signaturer parameters enumerate)rs_listr*sigrM)rrrrNfrom_string_list s4    zContainer.from_string_listcCs|jr|j|S|SdS)iCast a single item from a string Evaluated when parsing CLI configuration from a string N)rrrrSrqrMrMrNr s zContainer.item_from_string)N)rJrKrLrrryrr?r{r<rrr SequenceTypesrrrr>rrIrrrrrrr&rMrMr#rNr ? s $H    'r csbeZdZUdZeZefZej e d<de de j ffdd ZddZfd d Zfd d ZZS) r0zAn instance of a Python list.rNrc s(||_||_tjf||d|dS)aCreate 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 )rrN)_minlen_maxlenrrrrrZminlenmaxlenrr#rMrNr s"z List.__init__cCs(d|jt||j|j|f}t|dS)Nz_The '%s' trait of %s instance must be of length %i <= L <= %i, but a value of %s was specified.)rrrrr9)rrrrprMrMrN length_error s zList.length_errorcs6t|}||jks||jkr(|||t||SrO)rrrrrr)rrrlengthr#rMrNr& s zList.validate_elementscs,t|trt||gSt||SdSrO)rvr{rrrr#rMrNr- s zList.set)rJrKrLrrIrrrryrrr>sysmaxsizerrrrr&rMrMr#rNr0 s & r0csDeZdZdZeZeefZdZ de de j ffdd Z ddZZS) r6zAn instance of a Python set.)rrz{}Nrc stj||||fi|dS)aCreate 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 Nrrr#rMrNr= s"z Set.__init__cCs0tt|}|dkrdSd|dddS)Nrzset(){rr})r rr)rZ list_reprrMrMrNr a szSet.default_value_repr)rJrKrLrrrrrIrrr>rrrr r&rMrMr#rNr64 s$r6csReZdZdZeZefZfddZddZ ddZ fdd Z fd d Z Z S) r;zAn instance of a Python tuple.cs6|dt}t|dkr8|tur8t|ds8|d}d}|durj|ddsjtd|jjd td d t}|turxd}nB|durd}d|d<n,t ||j r|f}nt d |jjd |g|_ |D].}t |t rtdtd d |}|j |q|j r|dus|turd}tt|jf|j|d|dS)aGCreate 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` rrrrMNrFrrrrrr~Traits should be given as instances, not types (for example, `Int()`, not `Int`) Passing types is deprecated in traitlets 4.1.r)rKr>rrzrWrrrJrirvrrh_traitsrwrrr rr)rrrrrrr#rMrNro s@     zTuple.__init__cCs(|jr|t|jkr|S|j||S)r)rrrrrMrMrNr szTuple.item_from_stringc Cs|js |St|t|jkrDd|jt|t|jt|f}t|g}t|j|D]V\}}z|||}Wn2ty}z||||WYd}~qTd}~00| |qTt |S)NzTThe '%s' trait of %s instance requires %i elements, but a value of %s was specified.) rrrrr r9rrrrr)rrrrprrr"rrMrMrNr s $ zTuple.validate_elementscs8|jD]}t|tr||dqtt|||dSrO)rrvr:rrr rrkrrr#rMrNr s  zTuple.class_initcs4|jD]}t|tr||qtt||dSrO)rrvr:rrr rrrr#rMrNr s   zTuple.instance_init)rJrKrLrrrrIrrrrrrr&rMrMr#rNr;i s M  r;cseZdZdZdZdZdddeffdd ZdddZfdd Z d d Z fd d Z fddZ ddZ ddZddZZS)r"aAn 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  s|dd}|dur6|dur$td|}tdtdd|dd}|durl|durZtd|}td tdd|tur|durt|s|}d}|dur|durt|r|}d}|turi}|durd}n0t|tr|f}nt|tr|f}n td |t|r(t|t r td tdd|}||_ n|durBtd t |t|rtt|t rltd tdd|}||_ n|durtd t |||_ tjft|d|dS)aCreate 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()) rNzFFound 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 %sr)rKrhrrir>rzrvr)rrw _value_traitr _key_trait_per_key_traitsrr) r value_traitZper_key_traits key_traitrrrrrr#rMrNr s.            z Dict.__init__ValuescCs.|d|jt||t|f}t|dS)NzN of the '%s' trait of %s instance must be %s, but a value of %s was specified.)rrrr r9)rrelement validatorZsiderprMrMrN element_errorz szDict.element_errorcs*t||}|dur|S|||}|SrO)rrIrrr#rMrNrI s  z Dict.validatec Cs|jpi}|j}|j}|s&|s&|s&|Si}|D]}||}|rrz|||}Wn"typ||||dYn0|||} | rz| ||}Wn"ty|||| dYn0|||<q.||S)NZKeysr )r rrrr9rrWr) rrrZper_key_overrider r rrZr"Zactive_value_traitrMrMrNr s*      zDict.validate_elementscslt|jtr|j|dt|jtr4|j|d|jdurZ|jD]}||dqHt||dSrO)rvrr:rrr rLrrr#rMrNr s   zDict.class_initcsdt|jtr|j|t|jtr0|j||jdurT|jD]}||qDt|dSrO)rvrr:rrr rLrrr#rMrNr s      zDict.instance_initcCsht|ts&tdt|dt|z||gWStybt|}t|tr\|YSYn0dS)rz"from_string expects a string, got z of type N) rvr{rhr rwrrrur)rrMrMrNr s   zDict.from_stringcst|dkr"|ddkr"jr"dSt|dkrn|ddrn|ddrntdj|dtt|dSi}fdd |DD]}| |q|S) 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--{0}={1} for dict-traits is deprecated in traitlets 5.0. You can pass --{0} ... multiple times to add items to a dict.csg|]}|qSrMr)rrSrrMrNr; rz)Dict.from_string_list..) rrrrrr`rrrr)rrcombinedr@rMrrNr s (  zDict.from_string_listcCsld|vr td|jjt|f|dd\}}|jrB|j|}|jpJi||j }|rd||}||iS)aCast a single-key dict from a string. Evaluated when parsing CLI configuration from a string. Dicts expect strings of the form key=value. Returns a one-key dictionary, which will be merged in :meth:`.from_string_list`. r<z3'%s' options must have the form 'key=value', got %sr) r9rrJr rdrrr rWr)rrSrZrr rMrMrNr s   zDict.item_from_string)r )rJrKrLrrrr>rrrIrrrrrrr&rMrMr#rNr" s     r"c@s(eZdZdZdZdZddZddZdS) r7zgA trait for an (ip, port) tuple. This allows for both IPv4 IP addresses as well as hostnames. )z 127.0.0.1rzan (ip, port) tuplecCs^t|trNt|dkrNt|dtrNt|dtrN|d}|dkrN|dkrN|S|||dS)Nrrri)rvrrr{rr)rrrportrMrMrNrI s  zTCPAddress.validatecCsF|jr|dkrdSd|vr&td||dd\}}t|}||fS)Nr:zRequire `ip:port`, got %rr)rrtrdr)rrSiprrMrMrNr s zTCPAddress.from_stringNrrMrMrMrNr7 s  r7c@seZdZdZdZddZdS)rzA casting compiled regular expression trait. Accepts both strings and compiled regular expressions. The resulting attribute will be a compiled regular expression.za regular expressioncCs0z t|WSty*|||Yn0dSrO)recompilerrrrMrMrNrI" s  zCRegExp.validateNrJrKrLrrrIrMrMrMrNr srcseZdZUdZdZejeje d<dZ dfdd Z e fddZ e fd d Zd d ZdddZdddZddZddZZS)r@aUse 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 Nrz"Trait type adapter to a Enum classc snt|tjsJd||dd}|durB|sBt|jd}tjfd|i|||_ |j d|_ dS)NzREQUIRE: enum.Enum, but was: %rrFrrr_) rxenumr$rWrI __members__rLrr enum_classrJ name_prefix)rrrrrr#rMrNrG s  zUseEnum.__init__cCs:t|tsJ|jj}|D]}|j|kr|Sq|S)z0Selects enum-value by using its number-constant.)rvrrrrLr)rrrB enum_membersZ enum_itemrMrMrNselect_by_numberP s    zUseEnum.select_by_numbercCs:t|tsJ||jr*||jdd}|jj||S)z4Selects enum-value by using its name or scoped-name.rr)rvr{rrreplacerrrW)rrrBrMrMrNselect_by_nameZ s zUseEnum.select_by_namecCs|t||jr|St|tr2||}|turl|Sn:t|trT||}|turl|Sn|durl|jrfdS|jS| ||dSrO) rvrrrr>r{rrrr)rrrZvalue2rMrMrNrIb s     zUseEnum.validateFcCs4|jj}|r$ddd|DStt|SdS)rrcss|]}d|VqdSrrMrrMrMrNrz rz'UseEnum._choices_str..N)rrrrr rIrrMrMrNrv s zUseEnum._choices_strcCs.|jrd|rdndnd}d|||SrrrrMrMrNr~ sz UseEnum._infocCs |jddSrrrrMrMrNr sz UseEnum.infocCs |jddSrrrrMrMrNr szUseEnum.info_rst)N)F)F)rJrKrLrrryrrr$rrrr>rrrIrrrrr&rMrMr#rNr@) s    r@c@seZdZdZdZddZdS)rzxA trait which is callable. Notes ----- Classes are callable, as are instances with a __call__() method.z a callablecCst|r |S|||dSrO)rdrrrMrMrNrI szCallable.validateNrrMrMrMrNr sr)N)orrrrarUrrrtypingryastrwarningsrrZ utils.bunchrZutils.descriptionsrrr r Zutils.getargspecr Zutils.importstringr Zutils.sentinelrrIrr frozensetrrwZ ClassTypes__all__r>rZNoDefaultSpecifiedrr9rZ_name_rerQrXr[rqrurzrHr~rrrErCrDrr:r rr2r3rFrGrIrBr%r5rAr!r+r,rr<r-r(r)r'r8r?rrr.rr1rr/r&rrrrrr=rr4r#rrr$rr*r r0r6r;r"r7rr@rrMrMrMrNs)      E    QC3t$.$!)  ) _`X    #   )65A5a