3 d4@sdZddlmZddlZddlmZmZddlmZm Z ddl m Z m Z m Z ddl mZdd lmZdd lmZmZdd lmZdd lmZdd lmZmZddlmZeefZee jee fe!e je!ee fiZ"dZ#ddZ$ddZ%GdddeZ&Gddde&Z'GdddeZ(GdddeZ)GdddeZ*GdddeZ+Gd d!d!eZ,Gd"d#d#e,Z-Gd$d%d%eZ.Gd&d'd'eZ/Gd(d)d)eZ0d*d+Z1Gd,d-d-eZ2dS).a Defines a standard set of TraitHandler subclasses. A trait handler mediates the assignment of values to object traits. It verifies (via its validate() method) that a specified value is consistent with the object trait, and generates a TraitError exception if it is not consistent. ) import_moduleN) FunctionType MethodType) DefaultValue ValidateTrait) SequenceTypes TypeTypesclass_of) RangeTypes) TraitError)TraitDictEventTraitDictObject) trait_from) TraitHandler)TraitListEventTraitListObject) deprecatedzI'{handler}' trait handler has been deprecated. Use {replacement} instead.cCstd|t|fdS)NzMThe '%s' trait of %s instance is a property that has no 'get' or 'set' method)r r )objectnamer7/tmp/pip-build-7vycvbft/traits/traits/trait_handlers.py_undefined_get6srcCst||dS)N)r)rrvaluerrr_undefined_set@src@s0eZdZdZddZddZddZdd Zd S) TraitCoerceTypeaBEnsures that a value assigned to a trait attribute is of a specified Python type, or can be coerced to the specified type. TraitCoerceType is the underlying handler for the predefined traits and factories for Python simple types. The TraitCoerceType class is also an example of a parametrized type, because the single TraitCoerceType class allows creating instances that check for totally different sets of values. For example:: class Person(HasTraits): name = Trait('', TraitCoerceType('')) weight = Trait(0.0, TraitCoerceType(float)) In this example, the **name** attribute must be of type ``str`` (string), while the **weight** attribute must be of type ``float``, although both are based on instances of the TraitCoerceType class. Note that this example is essentially the same as writing:: class Person(HasTraits): name = Trait('') weight = Trait(0.0) This simpler form is automatically changed by the Trait() function into the first form, based on TraitCoerceType instances, when the trait attributes are defined. For attributes based on TraitCoerceType instances, if a value that is assigned is not of the type defined for the trait, a TraitError exception is raised. However, in certain cases, if the value can be coerced to the required type, then the coerced value is assigned to the attribute. Only *widening* coercions are allowed, to avoid any possible loss of precision. The following table lists the allowed coercions. ============ ================= Trait Type Coercible Types ============ ================= complex float, int float int ============ ================= Parameters ---------- aType : type or object Either a Python type or a Python value. If this is an object, it is mapped to its corresponding type. For example, the string 'cat' is automatically mapped to ``str``. Attributes ---------- aType : type A Python type to coerce values to. c CsDt|tst|}||_yt||_Wntj|f|_YnXdS)N) isinstancetypeaTypeCoercableTypes fast_validatercoerce)selfrrrr__init__zs zTraitCoerceType.__init__cCsZ|j}t|}||dkr|Sx(|ddD]}||kr,|d|Sq,W|j|||dS)Nr)r rerror)r"rrrfvtvZtypeirrrvalidates zTraitCoerceType.validatecCsdt|jddS)Nz a value of %sr)strr)r"rrrinfoszTraitCoerceType.infocCsf|jtkr.|jdkr(ddlm}||_|jS|j}|dkr@d}ddlm}|||jpXd|jddS)Nr) BooleanEditorT) TextEditorFr)auto_set enter_setevaluate) rbooleditor traitsui.apir,r.r-r/r )r"traitr,r.r-rrr get_editors    zTraitCoerceType.get_editorN)__name__ __module__ __qualname____doc__r#r(r+r5rrrrrDs 4 rc@s eZdZdZddZddZdS) TraitCastTypea5Ensures that a value assigned to a trait attribute is of a specified Python type, or can be cast to the specified type. This class is similar to TraitCoerceType, but uses casting rather than coercion. Values are cast by calling the type with the value to be assigned as an argument. When casting is performed, the result of the cast is the value assigned to the trait attribute. Any trait that uses a TraitCastType instance in its definition ensures that its value is of the type associated with the TraitCastType instance. For example:: class Person(HasTraits): name = Trait('', TraitCastType('')) weight = Trait(0.0, TraitCastType(float)) In this example, the **name** trait must be of type ``str`` (string), while the **weight** trait must be of type ``float``. Note that this example is essentially the same as writing:: class Person(HasTraits): name = CStr weight = CFloat To understand the difference between TraitCoerceType and TraitCastType (and also between Float and CFloat), consider the following example:: >>> class Person(HasTraits): ... weight = Float ... cweight = CFloat ... >>> bill = Person() >>> bill.weight = 180 # OK, coerced to 180.0 >>> bill.cweight = 180 # OK, cast to 180.0 >>> bill.weight = '180' # Error, invalid coercion >>> bill.cweight = '180' # OK, cast to float('180') Parameters ---------- aType : type Either a Python type or a Python value. If this is an object, it is mapped to its corresponding type. For example, the string 'cat' is automatically mapped to ``str``. Attributes ---------- aType : type A Python type to cast values to. cCs(t|tst|}||_tj|f|_dS)N)rrrrcastr )r"rrrrr#s zTraitCastType.__init__c Cs<t||jkr|Sy |j|S|j|||YnXdS)N)rrr%)r"rrrrrrr(s  zTraitCastType.validateN)r6r7r8r9r#r(rrrrr:s1r:c@sbeZdZdZdddZddZdd Zd d Zd d ZddZ ddZ ddZ ddZ ddZ dS) TraitInstanceaEnsures that trait attribute values belong to a specified Python type. Any trait that uses a TraitInstance handler ensures that its values belong to the specified type or class (or one of its subclasses). For example:: class Employee(HasTraits): manager = Trait(None, TraitInstance(Employee, True)) This example defines a class Employee, which has a **manager** trait attribute, which accepts either None or an instance of Employee as its value. TraitInstance ensures that assigned values are exactly of the type specified (i.e., no coercion is performed). Parameters ---------- aClass : type, object or str A Python type or a string that identifies the type, or an object. If this is an object, it is mapped to the class it is an instance of. If this is a str, it is either the name of a class in the module identified by the module parameter, or an identifier of the form "*module_name*[.*module_name*....].*class_name*". allow_none : bool Flag indicating whether None is accepted as a valid value. module : str The name of the module that the class belongs to. This is ignored if the type is provided directly, or the str value is an identifier with '.'s in it. Attributes ---------- aClass : type or str A Python type, or a string which identifies the type. If this is a str, it is either the name of a class in the module identified by the module attribute, or an identifier of the form "*module_name*[.*module_name*....].*class_name*". A string value will be replaced by the actual type object the first time the trait is used to validate an object. module : str The name of the module that the class belongs to. This is ignored if the type is provided directly, or the str value is an identifier with '.'s in it. TcCs@||_||_t|tr||_nt|ts.|j}||_|jdS)N) _allow_nonemodulerr*aClassr __class__set_fast_validate)r"r@ allow_noner?rrrr##s  zTraitInstance.__init__cCsd|_t|dr|jdS)z Whether or not None is permitted as a valid value. Returns ------- bool Whether or not None is a valid value. Tr N)r>hasattrrB)r"rrrrC.s zTraitInstance.allow_nonecCsBtj|jg}|jr tjd|jg}|jtkr4tj|d<t||_dS)Nr)rinstancer@r>r rtupler )r"r rrrrB:s    zTraitInstance.set_fast_validatecCs\|dkr |jr|S|j|||t|jtr:|j|||t||jrJ|S|j|||dS)N)r>r%rr@r* resolve_class)r"rrrrrrr(Bs  zTraitInstance.validatecCs2|j}t|tk r|j}t|}|jr.|dS|S)Nz or None)r@rr*r6r r>)r"r@resultrrrr+Qs zTraitInstance.infocCsn|j|j|j}|dkr(|j|||||_|j|j|}|j}||k r^t|dr^|j}|j |j dS)N item_trait) validate_class find_classr@r%rBZ base_traithandlerrDrI set_validater )r"rrrr@r4rLrrrrG]s  zTraitInstance.resolve_classc Cs|j}|jd}|dkr4|d|}||dd}ttjj||d}|dkr|dkryt|}t||d}Wntk rYnX|S)N.rr)r?rfindgetattrsysmodulesgetr Exception)r"klassr?colZtheClassmodrrrrKrs  zTraitInstance.find_classcCs|S)Nr)r"r@rrrrJszTraitInstance.validate_classcOsL|d}t|tr:|j|j|}|dkr:td|d||dd|S)NrzUnable to locate class: r)rr*rJrKr )r"argskwr@rrrcreate_default_values  z"TraitInstance.create_default_valuecCs>|jdkr8ddlm}||jp d|jp(d|jp0dd|_|jS)Nr)InstanceEditorr=Zlive)labelviewkind)r2r3r[r\r]r^)r"r4r[rrrr5s  zTraitInstance.get_editorN)Tr=)r6r7r8r9r#rCrBr(r+rGrKrJrZr5rrrrr<s,    r<c@s(eZdZdZddZddZddZdS) TraitFunctionaXEnsures that assigned trait attribute values are acceptable to a specified validator function. TraitFunction is the underlying handler for the predefined trait **Function**, and for the use of function references as arguments to the Trait() function. The signature of the function must be of the form *function*(*object*, *name*, *value*). The function must verify that *value* is a legal value for the *name* trait attribute of *object*. If it is, the value returned by the function is the actual value assigned to the trait attribute. If it is not, the function must raise a TraitError exception. Parameters ---------- aFunc : function A function to validate trait attribute values. Attributes ---------- aFunc : function A function to validate trait attribute values. cCs(t|tstd||_tj|f|_dS)NzArgument must be callable.)r CallableTypesr aFuncrfunctionr )r"rarrrr#s zTraitFunction.__init__c Cs6y|j|||Stk r0|j|||YnXdS)N)rar r%)r"rrrrrrr(szTraitFunction.validatec Cs(y|jjS|jjr |jjSdSdS)Nz a legal value)rar+r9)r"rrrr+s zTraitFunction.infoN)r6r7r8r9r#r(r+rrrrr_sr_c@s0eZdZdZddZddZddZdd Zd S) TraitEnuma Ensures that a value assigned to a trait attribute is a member of a specified list of values. TraitEnum is the underlying handler for the forms of the Trait() function that take a list of possible values The list of legal values can be provided as a list or tuple of values. That is, ``TraitEnum([1, 2, 3])``, ``TraitEnum((1, 2, 3))`` and ``TraitEnum(1, 2, 3)`` are equivalent. For example:: class Flower(HasTraits): color = Trait('white', TraitEnum(['white', 'yellow', 'red'])) kind = Trait('annual', TraitEnum('annual', 'perennial')) This example defines a Flower class, which has a **color** trait attribute, which can have as its value, one of the three strings, 'white', 'yellow', or 'red', and a **kind** trait attribute, which can have as its value, either of the strings 'annual' or 'perennial'. This is equivalent to the following class definition:: class Flower(HasTraits): color = Trait(['white', 'yellow', 'red']) kind = Trait('annual', 'perennial') The Trait() function automatically maps traits of the form shown in this example to the form shown in the preceding example whenever it encounters them in a trait definition. Parameters ---------- *values Either all legal values for the enumeration, or a single list or tuple of the legal values. Attributes ---------- values : tuple Enumeration of all legal values for a trait. cGs@t|dkr$t|dtkr$|d}t||_tj|jf|_dS)Nrr)lenrrrFvaluesrenumr )r"rerrrr#s zTraitEnum.__init__cCs ||jkr|S|j|||dS)N)rer%)r"rrrrrrr(s zTraitEnum.validatecCsdjdd|jDS)Nz or cSsg|] }t|qSr)repr).0xrrr sz"TraitEnum.info..)joinre)r"rrrr+szTraitEnum.infocCs*ddlm}|||jpd|j|jp$ddS)Nr) EnumEditorZradio)recolsr0mode)r3rlrnr0ro)r"r4rlrrrr5s  zTraitEnum.get_editorN)r6r7r8r9r#r(r+r5rrrrrcs 'rcc@sJeZdZdZeejdddddZddZdd Z d d Z d d Z dS)TraitPrefixListaEnsures that a value assigned to a trait attribute is a member of a list of specified string values, or is a unique prefix of one of those values. .. deprecated:: 6.1 :class:`~.TraitPrefixList` is scheduled for removal in Traits 7.0. Use the :class:`~.PrefixList` trait type instead. TraitPrefixList is a variation on TraitEnum. The values that can be assigned to a trait attribute defined using a TraitPrefixList handler is the set of all strings supplied to the TraitPrefixList constructor, as well as any unique prefix of those strings. That is, if the set of strings supplied to the constructor is described by [*s*\ :sub:`1`\ , *s*\ :sub:`2`\ , ..., *s*\ :sub:`n`\ ], then the string *v* is a valid value for the trait if *v* == *s*\ :sub:`i[:j]` for one and only one pair of values (i, j). If *v* is a valid value, then the actual value assigned to the trait attribute is the corresponding *s*\ :sub:`i` value that *v* matched. As with TraitEnum, the list of legal values can be provided as a list or tuple of values. That is, ``TraitPrefixList(['one', 'two', 'three'])`` and ``TraitPrefixList('one', 'two', 'three')`` are equivalent. Example ------- :: class Person(HasTraits): married = Trait('no', TraitPrefixList('yes', 'no') The Person class has a **married** trait that accepts any of the strings 'y', 'ye', 'yes', 'n', or 'no' as valid values. However, the actual values assigned as the value of the trait attribute are limited to either 'yes' or 'no'. That is, if the value 'y' is assigned to the **married** attribute, the actual value assigned will be 'yes'. Note that the algorithm used by TraitPrefixList in determining whether a string is a valid value is fairly efficient in terms of both time and space, and is not based on a brute force set of comparisons. Parameters ---------- *values Either all legal string values for the enumeration, or a single list or tuple of legal string values. Attributes ---------- values : tuple of strings Enumeration of all legal values for a trait. Z PrefixList)rL replacementcGsft|dkr$t|dtkr$|d}|dd|_i|_}x|D] }|||<qBWtj||jf|_dS)Nrr) rdrrrevalues_r prefix_mapr(r )r"rerrkeyrrrr#@s   zTraitPrefixList.__init__c Csyr||jkrjd}t|}x0|jD]&}||d|kr |dk rBd}P|}q W|dkr`|j|||||j|<|j|S|j|||YnXdS)N)rrrdrer%)r"rrrmatchnrtrrrr(Ks     zTraitPrefixList.validatecCsdjdd|jDdS)Nz or cSsg|] }t|qSr)rg)rhrirrrrj_sz(TraitPrefixList.info..z (or any unique prefix))rkre)r"rrrr+]szTraitPrefixList.infocCsddlm}|||jpddS)Nr)rlrm)rern)r3rlrn)r"r4rlrrrr5cs zTraitPrefixList.get_editorcCs|jj}d|kr|d=|S)Nr )__dict__copy)r"rHrrr __getstate__hs zTraitPrefixList.__getstate__N) r6r7r8r9r_WARNING_FORMAT_STRformatr#r(r+r5ryrrrrrp s3 rpc@sDeZdZdZdZddZddZddZd d Zd d Z d dZ dS)TraitMapa Checks that the value assigned to a trait attribute is a key of a specified dictionary, and also assigns the dictionary value corresponding to that key to a *shadow* attribute. A trait attribute that uses a TraitMap handler is called *mapped* trait attribute. In practice, this means that the resulting object actually contains two attributes: one whose value is a key of the TraitMap dictionary, and the other whose value is the corresponding value of the TraitMap dictionary. The name of the shadow attribute is simply the base attribute name with an underscore ('_') appended. Mapped trait attributes can be used to allow a variety of user-friendly input values to be mapped to a set of internal, program-friendly values. Example ------- The following example defines a ``Person`` class:: >>> class Person(HasTraits): ... married = Trait('yes', TraitMap({'yes': 1, 'no': 0 }) ... >>> bob = Person() >>> print bob.married yes >>> print bob.married_ 1 In this example, the default value of the ``married`` attribute of the Person class is 'yes'. Because this attribute is defined using TraitPrefixList, instances of Person have another attribute, ``married_``, whose default value is 1, the dictionary value corresponding to the key 'yes'. Parameters ---------- map : dict A dictionary whose keys are valid values for the trait attribute, and whose corresponding values are the values for the shadow trait attribute. Attributes ---------- map : dict A dictionary whose keys are valid values for the trait attribute, and whose corresponding values are the values for the shadow trait attribute. TcCs||_tj|f|_dS)N)maprr )r"r}rrrr#szTraitMap.__init__c Cs2y||jkr|SWn YnX|j|||dS)N)r}r%)r"rrrrrrr(s  zTraitMap.validatecCs |j|S)z# Get the mapped value for a value. )r})r"rrrr mapped_valueszTraitMap.mapped_valuec Cs4yt||d|j|WntdYnXdS)N_Z Unmappable)setattrr~r )r"rrrrrr post_setattrszTraitMap.post_setattrcCs"tdd|jjD}dj|S)Ncss|]}t|VqdS)N)rg)rhrirrr sz TraitMap.info..z or )sortedr}keysrk)r"rrrrr+sz TraitMap.infocCsddlm}|||jpddS)Nr)rlrm)rern)r3rlrn)r"r4rlrrrr5s zTraitMap.get_editorN) r6r7r8r9 is_mappedr#r(r~rr+r5rrrrr|ps/ r|csBeZdZdZeejdddddZddZfdd Z Z S) TraitPrefixMapaXA cross between the TraitPrefixList and TraitMap classes. .. deprecated:: 6.1 :class:`~.TraitPrefixMap` is scheduled for removal in Traits 7.0. Use the :class:`~.PrefixMap` trait type instead. Like TraitMap, TraitPrefixMap is created using a dictionary, but in this case, the keys of the dictionary must be strings. Like TraitPrefixList, a string *v* is a valid value for the trait attribute if it is a prefix of one and only one key *k* in the dictionary. The actual values assigned to the trait attribute is *k*, and its corresponding mapped attribute is *map*[*k*]. Example ------- :: mapping = {'true': 1, 'yes': 1, 'false': 0, 'no': 0 } boolean_map = Trait('true', TraitPrefixMap(mapping)) This example defines a Boolean trait that accepts any prefix of 'true', 'yes', 'false', or 'no', and maps them to 1 or 0. Parameters ---------- map : dict A dictionary whose keys are strings that are valid values for the trait attribute, and whose corresponding values are the values for the shadow trait attribute. Attributes ---------- map : dict A dictionary whose keys are strings that are valid values for the trait attribute, and whose corresponding values are the values for the shadow trait attribute. Z PrefixMap)rLrqcCs>||_i|_}x|jD] }|||<qWtj||jf|_dS)N)r}_maprrrsr(r )r"r}rrtrrrr#s   zTraitPrefixMap.__init__c Csyv||jkrnd}t|}x4|jjD]&}||d|kr$|dk rFd}P|}q$W|dkrd|j|||||j|<|j|S|j|||YnXdS)N)rrdr}rr%)r"rrrrurvrtrrrr(s    zTraitPrefixMap.validatecstjdS)Nz (or any unique prefix))superr+)r")rArrr+szTraitPrefixMap.info) r6r7r8r9rrzr{r#r(r+ __classcell__rr)rArrs %rc@s`eZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ dS) TraitCompounda Provides a logical-OR combination of other trait handlers. This class provides a means of creating complex trait definitions by combining several simpler trait definitions. TraitCompound is the underlying handler for the general forms of the Trait() function. A value is a valid value for a trait attribute based on a TraitCompound instance if the value is valid for at least one of the TraitHandler or trait objects supplied to the constructor. In addition, if at least one of the TraitHandler or trait objects is mapped (e.g., based on a TraitMap or TraitPrefixMap instance), then the TraitCompound is also mapped. In this case, any non-mapped traits or trait handlers use identity mapping. Parameters ---------- *handlers Either all TraitHandlers or trait objects to be combined, or a single list or tuple of TraitHandlers or trait objects. Attributes ---------- handlers : list or tuple A list or tuple of TraitHandler or trait objects to be combined. cGs6t|dkr$t|dtkr$|d}||_|jdS)Nrr)rdrrhandlersrM)r"rrrrr#&szTraitCompound.__init__c Cs|d|_d|_d|_g}g}g}g}g}x|jD]}t|dd}|dk r||j|j|dtjkrp|j |dq|j|n |j|jt|dd}|dk r|j||jrd|_|j|nd|_|jr.d|_q.W||_ ||_ |jr||_ nt |dr|` t|dkr:t|dkr(|jtj|ftjt|f|_nt |drJ|`t|dkrh||_|j|_nt |drx|`dS)NFTr rrrmapped_handlers)r has_itemsZ reversablerrPappendr(rcomplexextend validatesslow_validatesrrDrdZslowrFr post_setattrs _post_setattrr) r"rrrZfast_validatesrrLr&rrrrrM,sT             zTraitCompound.set_validatec Cs@x0|jD]&}y ||||Stk r,YqXqW|j|||S)N)rr slow_validate)r"rrrr(rrrr(ks    zTraitCompound.validatec CsDx0|jD]&}y ||||Stk r,YqXqW|j|||dS)N)rr r%)r"rrrr(rrrrss    zTraitCompound.slow_validatecsdjfdd|jDS)Nz or csg|]}|jqSr) full_info)rhri)rrrrrrj}sz+TraitCompound.full_info..)rkr)r"rrrr)rrrrr{szTraitCompound.full_infocCsdjdd|jDS)Nz or cSsg|] }|jqSr)r+)rhrirrrrjsz&TraitCompound.info..)rkr)r"rrrr+szTraitCompound.infoc Cs,x&|jD]}y |j|SYqXqW|S)N)rr~)r"rrLrrrr~s    zTraitCompound.mapped_valuec CsJx4|jD]*}y||||dStk r0YqXqWt||d|dS)Nr)rr r)r"rrrrrrrrs   zTraitCompound._post_setattrc srddlm}m}fdd|jD}|}d}g}x4|D],}t||jrZ|d7}|dkrZq8|j|q8W||dS)Nr)r-CompoundEditorcsg|]}|jqSr)r5)rhri)r4rrrjsz,TraitCompound.get_editor..r)editors)r3r-rrrrAr) r"r4r-rZ the_editorsZ text_editorcountrr2r)r4rr5s  zTraitCompound.get_editorcCstS)N) items_event)r"rrrrszTraitCompound.items_eventN)r6r7r8r9r#rMr(rrr+r~rr5rrrrrr s? rc@sJeZdZdZeejdddddZddZdd Z d d Z d d Z dS) TraitTupleae Ensures that values assigned to a trait attribute are tuples of a specified length, with elements that are of specified types. TraitTuple is the underlying handler for the predefined trait **Tuple**, and the trait factory Tuple(). Example ------- The following example defines a ``Card`` class:: rank = Range(1, 13) suit = Trait('Hearts', 'Diamonds', 'Spades', 'Clubs') class Card(HasTraits): value = Trait(TraitTuple(rank, suit)) The Card class has a **value** trait attribute, which must be a tuple of two elments. The first element must be an integer in the range from 1 to 13, and the second element must be one of the four strings, 'Hearts', 'Diamonds', 'Spades', or 'Clubs'. Parameters ---------- *args The traits, each *trait*\ :sub:`i` specifies the type that the *i*\ th element of a tuple must be. Each *trait*\ :sub:`i` must be either a trait, or a value that can be converted to a trait using the trait_from() function. The resulting trait handler accepts values that are tuples of the same length as *args*, and whose *i*\ th element is of the type specified by *trait*\ :sub:`i`. Parameters ---------- types : tuple of CTrait instances The traits to use for each item in a validated tuple. Tuple)rLrqcGs&tdd|D|_tj|jf|_dS)NcSsg|] }t|qSr)r)rhargrrrrjsz'TraitTuple.__init__..)rFtypesrr )r"rXrrrr#szTraitTuple.__init__c Csy`t|tr^|j}t|t|kr^g}x.t|D]"\}}|j|jj||||q0Wt|SWn YnX|j|||dS)N) rrFrrd enumeraterrLr(r%)r"rrrrreirrrrr(s  zTraitTuple.validatecs$ddjfddjDS)Nza tuple of the form: (%s)z, csg|]}j|qSr) _trait_info)rhr)rrr"rrrrjsz(TraitTuple.full_info..)rkr)r"rrrr)rrr"rrrszTraitTuple.full_infocCs |j}|dkrdS|j|||S)Nz any value)rLr)r"rrrrrLrrrrszTraitTuple._trait_infocCs(ddlm}||j|jpg|jp"ddS)Nr) TupleEditorr)rlabelsrn)r3rrrrn)r"r4rrrrr5s zTraitTuple.get_editorN) r6r7r8r9rrzr{r#r(rrr5rrrrrs% rc@sleZdZdZdZejZdZe e j ddddde j dfddZd d Zd d Zd dZddZddZdS) TraitLista Ensures that a value assigned to a trait attribute is a list containing elements of a specified type, and that the length of the list is also within a specified range. TraitList also makes sure that any changes made to the list after it is assigned to the trait attribute do not violate the list's type and length constraints. TraitList is the underlying handler for the predefined list-based traits. Example ------- :: class Card(HasTraits): pass class Hand(HasTraits): cards = Trait([], TraitList(Trait(Card), maxlen=52)) This example defines a Hand class, which has a **cards** trait attribute, which is a list of Card objects and can have from 0 to 52 items in the list. Parameters ---------- trait : Trait The type of items the list can contain. If this is None or omitted, then no type checking is performed on any items in the list; otherwise, this must be either a trait, or a value that can be converted to a trait using the trait_from() function. minlen : int The minimum length of the list. maxlen : int The maximum length of the list. has_items : bool Flag indicating whether the list contains elements. Attributes ---------- item_trait : CTrait or None The type of items the list can contain. If None, no type checking is performed on the items of the list. minlen : int The minimum length of the list. maxlen : int The maximum length of the list. has_items : bool Flag indicating whether the list contains elements. NList)rLrqrTcCs,t||_td||_t|||_||_dS)Nr)rrImaxminlenmaxlenr)r"r4rrrrrrr#5s   zTraitList.__init__cCst|j|j|j|jS)N)rrIrrr)r"rrrclone?szTraitList.clonecCsJt|tr8|jt|ko$|jknr8t||||S|j|||dS)N)rlistrrdrrr%)r"rrrrrrr(Ds  zTraitList.validatecCs|jdkr(|jtjkrd}qPd|j}n(|jtjkr@d|j}nd|j|jf}|jj}|dkrfd}nd|j|||}d||fS) Nritemszat most %d itemszat least %d itemszfrom %s to %s itemsr=z which are %sza list of %s%s)rrrQmaxsizerIrLr)r"rrrsizerLr+rrrrLs     zTraitList.full_infocCsddlm}|||S)Nr) list_editor)Ztraits.editor_factoriesr)r"r4rrrrr5_s zTraitList.get_editorcCstS)N)r)r"rrrrdszTraitList.items_event)r6r7r8r9 info_traitrtrait_list_objectdefault_value_type _items_eventrrzr{rQrr#rr(rr5rrrrrrs1 rcCs.ddlm}tjdkr(|tddjt_tjS)Nr)EventF)is_base) trait_typesrrrr as_ctrait)rrrrrhs   rc@sbeZdZdZdZejZdZe e j ddddddZ dd Z d d Zd d ZddZddZdS) TraitDicta Ensures that values assigned to a trait attribute are dictionaries whose keys and values are of specified types. TraitDict also makes sure that any changes to keys or values made that are made after the dictionary is assigned to the trait attribute satisfy the type constraints. TraitDict is the underlying handler for the dictionary-based predefined traits, and the Dict() trait factory. Example ------- :: class WorkoutClass(HasTraits): member_weights = Trait({}, TraitDict(str, float)) This example defines a WorkoutClass class containing a *member_weights* trait attribute whose value must be a dictionary containing keys that are strings (i.e., the members' names) and whose associated values must be floats (i.e., their most recently recorded weight). Parameters ---------- key_trait : trait The type for the dictionary keys. If this is None or omitted, the keys in the dictionary can be of any type. Otherwise, this must be either a trait, or a value that can be converted to a trait using the trait_from() function. In this case, all dictionary keys are checked to ensure that they are of the type specified. value_trait : trait The type for the dictionary values. If this is None or omitted, the values in the dictionary can be of any type. Otherwise, this must be either a trait, or a value that can be converted to a trait using the trait_from() function. In this case, all dictionary values are checked to ensure that they are of the type specified. has_items : bool Flag indicating whether the dictionary contains entries. Attributes ---------- key_trait : CTrait or TraitHandler or None The type for the dictionary keys. If this is None then the keys are not validated. value_trait : CTrait or TraitHandler or None The type for the dictionary values. If this is None then the values are not validated. value_handler : BaseTraitHandler or None The trait handler for the dictionary values. has_items : bool Flag indicating whether the dictionary contains entries. NDict)rLrqTcCs@t||_t||_||_|jj}|jr6|j}d|_||_dS)NF)r key_trait value_traitrrLr value_handler)r"rrrrLrrrr#s  zTraitDict.__init__cCst|j|j|jS)N)rrrr)r"rrrrszTraitDict.clonecCs*t|trt||||S|j|||dS)N)rdictrr%)r"rrrrrrr(s zTraitDict.validatecCshd}|jj}|dk r&d|j|||}|j}|dk r`|dkrBd}n|d7}|d|j|||7}d|S)Nr=z with keys which are %sz withz andz values which are %sza dictionary%s)rrLrr)r"rrrextrarLrrrrs zTraitDict.full_infocCs(|jdkr"ddlm}|td|_|jS)Nr)r-)r0)r2r3r-eval)r"r4r-rrrr5s   zTraitDict.get_editorcCs.ddlm}tjdkr(|tddjt_tjS)Nr)rF)r)rrrrr r)r"rrrrrs   zTraitDict.items_event)NNT)r6r7r8r9rrrrrrrzr{r#rr(rr5rrrrrrss3  r)3r9 importlibrrQrrr constantsrrZ trait_baserr r r Z trait_errorsr Ztrait_dict_objectr rZtrait_convertersrZ trait_handlerrrrrZutil.deprecatedrr`floatr!intrrrzrrrr:r<r_rcrpr|rrrrrrrrrrsB        lE'.BeVFVj