
NXc           @   sL  d  Z  d d l Z d d l Z d d l Z d d l Z d d l Z d d l m Z y& d d l m Z m Z e e	 f Z
 Wn e	 f Z
 n Xd d l m Z d d l m Z d d l m Z m Z d d	 l m Z d d
 l m Z d d l m Z e e e e f Z e d d d  Z e Z d e f d     YZ  d   Z! d   Z" d   Z# d   Z$ d   Z% d f  d     YZ& e' d  Z( d   Z) d e* f d     YZ+ d e* f d     YZ, e, Z- d e* f d     YZ. d  e. f d!     YZ/ d" e	 f d#     YZ0 d$ e j1 e0 e*  f d%     YZ2 d& e/ f d'     YZ3 d( e3 f d)     YZ4 d* e3 f d+     YZ5 d, e* f d-     YZ6 d. e6 e4 f d/     YZ7 d0 e6 e5 f d1     YZ8 d2 e3 f d3     YZ9 d4 e/ f d5     YZ: d6 e/ f d7     YZ; d8 e/ f d9     YZ< d: e< f d;     YZ= e j> r8e< e= f \ Z? Z@ e< ZA nB d< e/ f d=     YZ? d> e? f d?     YZ@ d@ e/ f dA     YZA dB e/ f dC     YZB dD eB f dE     YZC dF e/ f dG     YZD dH eD f dI     YZE dJ e/ f dK     YZF dL eF f dM     YZG dN e/ f dO     YZH dP eH f dQ     YZI dR e/ f dS     YZJ dT eJ f dU     YZK dV e/ f dW     YZL dX eL f dY     YZM dZ e/ f d[     YZN d\ eN f d]     YZO d^ e5 f d_     YZP d` eP f da     YZQ db eQ f dc     YZR dd eP f de     YZS df e5 f dg     YZT dh e/ f di     YZU dj e/ f dk     YZV d S(l   s  
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
iN(   t   FunctionType(   t	   ClassTypet   InstanceType(   t   warn(   t	   py3compat(   t	   iteritemst   string_typesi   (   t
   getargspec(   t   import_item(   t   Sentinelt	   Undefinedt	   traitletssA   
Used in Traitlets to specify that no defaults are set in kwargs
t
   TraitErrorc           B   s   e  Z RS(    (   t   __name__t
   __module__(    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   N   s   c         C   s,   t  |  t j  r t |   St |  j j  S(   s    Returns a string containing the class name of an object with the
    correct indefinite article ('a' or 'an') preceding it (e.g., 'an Image',
    'a PlotValue').
    (   t
   isinstanceR   R   t   add_articlet	   __class__R   (   t   object(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   class_ofV   s    
c         C   s&   |  d  j    d k r d |  Sd |  S(   st    Returns a string containing the correct indefinite article ('a' or 'an')
    prefixed to the specified string.
    i   t   aeious   an s   a (   t   lower(   t   name(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   a   s    c         C   sB   t  |   } t j r. | t k r. |  j } n  d |  | f } | S(   s]    Return a string representation of a value and its type for readable
    error messages.
    s   %r %r(   t   typeR   t   PY3R   R   (   t   objt   the_typet   msg(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt	   repr_typek   s
    c         C   s+   t  |  t  p* t  |  t  o* t |  t  S(   sN    Returns whether the given value is an instance or subclass of TraitType.
    (   R   t	   TraitTypeR   t
   issubclass(   t   t(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   is_traitw   s    c         C   sr   t  |  t  r |  g S|  d k r) d g St  |  t t f  rn x) |  D]! } t  | t  sE t d   qE W|  Sd S(   s   Convert the name argument to a list of names.

    Examples
    --------

    >>> parse_notifier_name('a')
    ['a']
    >>> parse_notifier_name(['a','b'])
    ['a', 'b']
    >>> parse_notifier_name(None)
    ['anytrait']
    t   anytraits   names must be stringsN(   R   R   t   Nonet   listt   tuplet   AssertionError(   R   t   n(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   parse_notifier_name~   s    t   _SimpleTestc           B   s,   e  Z d    Z d   Z d   Z d   Z RS(   c         C   s   | |  _  d  S(   N(   t   value(   t   selfR)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   __init__   s    c         C   s   | |  j  k S(   N(   R)   (   R*   t   test(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   __call__   s    c         C   s   d |  j  S(   Ns   <SimpleTest(%r)(   R)   (   R*   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   __repr__   s    c         C   s
   |  j    S(   N(   R.   (   R*   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   __str__   s    (   R   R   R+   R-   R.   R/   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR(      s   			c         C   s{   g  } xd t  |   D]V } y t |  |  } Wn t k
 r? q X| sS | |  r | j | | f  q q W| j   | S(   s  A 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.
    (   t   dirt   getattrt   AttributeErrort   appendt   sort(   R   t	   predicatet   resultst   keyR)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt
   getmembers   s    
c          G   s   x |  D] } t  |  d k s2 t d |   n  | \ } } t | t  sf t d t |    n  | | j   k r t d | | f   q q Wd S(   s.   Validate arguments for traitlet link functionsi   sK   Each linked traitlet must be specified as (HasTraits, 'trait_name'), not %rs%   Each object must be HasTraits, not %rs   %r has no trait %rN(   t   lent	   TypeErrorR   t	   HasTraitsR   t   traits(   t   tuplesR   R   t
   trait_name(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   _validate_link   s    t   linkc           B   sJ   e  Z d  Z e Z d   Z e j d    Z d   Z	 d   Z
 d   Z RS(   sC  Link traits from different objects together so they remain in sync.

    Parameters
    ----------
    source : (object / attribute name) pair
    target : (object / attribute name) pair

    Examples
    --------

    >>> c = link((src, 'value'), (tgt, 'value'))
    >>> src.value = 5  # updates other objects as well
    c         C   s   t  | |  | | |  _ |  _ z- t | d | d t | d | d   Wd  | d j |  j | d  | d j |  j | d  Xd  S(   Ni    i   (   R?   t   sourcet   targett   setattrR1   t   on_trait_changet   _update_targett   _update_source(   R*   RA   RB   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+      s    -c         c   s#   t  |  _ z	 d  VWd  t |  _ Xd  S(   N(   t   Truet   updatingt   False(   R*   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   _busy_updating   s    		c         C   sB   |  j  r d  S|  j   # t |  j d |  j d |  Wd  QXd  S(   Ni    i   (   RH   RJ   RC   RB   (   R*   R   t   oldt   new(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRE      s    	c         C   sB   |  j  r d  S|  j   # t |  j d |  j d |  Wd  QXd  S(   Ni    i   (   RH   RJ   RC   RA   (   R*   R   RK   RL   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRF      s    	c         C   sd   |  j  d j |  j |  j  d d t |  j d j |  j |  j d d t d \ |  _  |  _ d  S(   Ni    i   t   remove(   NN(   RA   RD   RE   RG   RB   RF   R"   (   R*   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   unlink   s    ''(   R   R   t   __doc__RI   RH   R+   t
   contextlibt   contextmanagerRJ   RE   RF   RN   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR@      s   				t   directional_linkc           B   sA   e  Z d  Z e Z d   Z e j d    Z d   Z	 d   Z
 RS(   sz  Link the trait of a source object with traits of target objects.

    Parameters
    ----------
    source : (object, attribute name) pair
    target : (object, attribute name) pair

    Examples
    --------

    >>> c = directional_link((src, 'value'), (tgt, 'value'))
    >>> src.value = 5  # updates target objects
    >>> tgt.value = 6  # does not update source object
    c         C   sv   t  | |  | | |  _ |  _ z- t | d | d t | d | d   Wd  |  j d j |  j |  j d  Xd  S(   Ni    i   (   R?   RA   RB   RC   R1   RD   t   _update(   R*   RA   RB   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+     s
    -c         c   s#   t  |  _ z	 d  VWd  t |  _ Xd  S(   N(   RG   RH   RI   (   R*   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRJ   
  s    		c         C   sB   |  j  r d  S|  j   # t |  j d |  j d |  Wd  QXd  S(   Ni    i   (   RH   RJ   RC   RB   (   R*   R   RK   RL   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRS     s    	c         C   s=   |  j  d j |  j |  j  d d t d \ |  _  |  _ d  S(   Ni    i   RM   (   NN(   RA   RD   RS   RG   R"   RB   (   R*   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRN     s    '(   R   R   RO   RI   RH   R+   RP   RQ   RJ   RS   RN   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRR      s   		t   BaseDescriptorc           B   s#   e  Z d  Z d Z d Z d   Z RS(   s  Base descriptor class

    Notes
    -----
    This implements Python's descriptor prototol.  

    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.
    c         C   s   d S(   sG  Part of the initialization which may depend on the underlying
        HasTraits 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.
        N(    (   R*   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   instance_init9  s    
N(   R   R   RO   R"   R   t
   this_classRU   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRT   #  s   R   c           B   s   e  Z d  Z i  Z e Z e Z d Z e d d  Z
 d   Z d   Z d   Z d   Z d   Z d d  Z d	   Z d
   Z d   Z d   Z d   Z d   Z d d  Z d   Z RS(   s&   A base class for all trait types.
    s	   any valuec         K   s   | t  k	 r | |  _ n  | d k	 r0 | |  _ n  d | k rI t d  n  t |  d k r t |  j  d k r |  j j   |  _ |  j j	 |  q | |  _ n |  j |  _ |  j
   d S(   s  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, but
        most trait types have ``allow_none=False`` by default.

        Extra information about the traitlet can be passed in as keyword
        arguments (``**metadata``). For instance, the config system uses 'config'
        and 'help' keywords.
        t   defaultsF   Parameter 'default' passed to TraitType. Did you mean 'default_value'?i    N(   R
   t   default_valueR"   t
   allow_noneR   R9   t   metadatat   copyt	   _metadatat   updatet   init(   R*   RX   RY   RZ   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+   O  s    
c         C   s   d  S(   N(    (   R*   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR^   q  s    c         C   s   t  d d d |  j S(   sn   DEPRECATED: Retrieve the static default value for this trait.

        Use self.default_value instead
        sA   get_default_value is deprecated: use the .default_value attributet
   stackleveli   (   R   RX   (   R*   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   get_default_valuet  s    	c         C   s9   t  d d d |  j | |  j  } | | j |  j <| S(   sE   DEPRECATED: Set the static default value for the trait type.
        sB   init_default_value is deprecated, and may be removed in the futureR_   i   (   R   t	   _validateRX   t   _trait_valuesR   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   init_default_value}  s
    	c         C   s|   |  j  rl t |  j   } d |  j  } xA | | j |  j  d  D]" } | | j k rC t | |  SqC Wn  t |  d d  S(   s=  Retrieve a callable to calculate the default for this traitlet.

        This looks for:

        - obj._{name}_default() on the class with the traitlet, or a subclass
          that obj belongs to.
        - trait.make_dynamic_default, which is defined by Instance

        If neither exist, it returns None
        s   _%s_defaulti   t   make_dynamic_defaultN(   R   R   t   mrot   indexRV   t   __dict__R1   R"   (   R*   R   Re   t	   meth_namet   cls(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   _dynamic_default_callable  s    	!c         C   sb   |  j  |  d  k r^ |  j t k	 r^ |  j | |  j  } |  j d  k	 r^ | | j |  j <q^ n  d  S(   N(   Rj   R"   RX   R
   Ra   R   Rb   (   R*   R   t   v(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRU     s
    c         C   s   | d k r |  Sy | j |  j } Wn t k
 r |  j |  } | d k rk t d |  j | f   n  |  j | |    } | | j |  j <| St k
 r t d   n X| Sd S(   sM  Get 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.
        s)   No default value found for %s trait of %rs=   Unexpected error in TraitType: default value not set properlyN(   R"   Rb   R   t   KeyErrorRj   R   Ra   t	   Exception(   R*   R   Ri   R)   t   dynamic_default(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   __get__  s    c         C   s   |  j  | |  } y | j |  j } Wn t k
 rB |  j } n X| | j |  j <y t | | k  } Wn t } n X| t k	 r | j |  j | |  n  d  S(   N(	   Ra   Rb   R   Rl   RX   t   boolRI   RG   t   _notify_trait(   R*   R   R)   t	   new_valuet	   old_valuet   silent(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   __set__  s    
c         C   se   | d  k r |  j r | St |  d  r= |  j | |  } n  | j t k ra |  j | |  } n  | S(   Nt   validate(   R"   RY   t   hasattrRv   t   _cross_validation_lockRI   t   _cross_validate(   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRa     s    c         C   sB   t  | d |  j  r> t | d |  j  } | | |   } n  | S(   Ns   _%s_validate(   Rw   R   R1   (   R*   R   R)   t   cross_validate(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRy     s    c         C   s7   t  | t  r# t |  g | j  St |  | g  Sd  S(   N(   R   t   Uniont   trait_types(   R*   t   other(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   __or__  s    c         C   s   |  j  S(   N(   t	   info_text(   R*   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   info  s    c         C   sl   | d  k	 r: d |  j t |  |  j   t |  f } n" d |  j |  j   t |  f } t |   d  S(   NsJ   The '%s' trait of %s instance must be %s, but a value of %s was specified.s;   The '%s' trait must be %s, but a value of %r was specified.(   R"   R   R   R   R   R   (   R*   R   R)   t   e(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   error  s    c         C   s   t  |  d i   j | |  S(   NR\   (   R1   t   get(   R*   R7   RW   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   get_metadata  s    c         C   s   | t  |  d i   | <d  S(   NR\   (   R1   (   R*   R7   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   set_metadata  s    N(   R   R   RO   RZ   R
   RX   RI   RY   R   R"   R+   R^   R`   Rc   Rj   RU   Ro   Ru   Ra   Ry   R~   R   R   R   R   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   F  s(   "															
t   MetaHasTraitsc           B   s    e  Z d  Z d   Z d   Z RS(   s   A metaclass for HasTraits.

    This metaclass makes sure that any TraitType class attributes are
    instantiated and sets their name attribute.
    c         C   s   xu t  |  D]g \ } } t | t  r4 | | _ q t j |  r t | t  rt |   } | | _ | | | <qt q q Wt t	 |   j
 |  | | |  S(   s   Create the HasTraits class.

        This instantiates all TraitTypes in the class dict and sets their
        :attr:`name` attribute.
        (   R   R   RT   R   t   inspectt   isclassR   R   t   superR   t   __new__(   t   mclsR   t   basest	   classdictt   kRk   t   vinst(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s    			c         C   sX   x5 t  |  D]' \ } } t | t  r |  | _ q q Wt t |   j | | |  d S(   s   Finish initializing the HasTraits class.

        This sets the :attr:`this_class` attribute of each BaseDescriptor in the
        class dict to the newly created class ``cls``.
        N(   R   R   RT   RV   R   R   R+   (   Ri   R   R   R   R   Rk   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+     s    (   R   R   RO   R   R+   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s   	R;   c           B   s   e  Z d  Z d   Z d   Z e j d    Z d   Z d   Z	 d   Z
 d e d  Z e d    Z e d	    Z e d
    Z d   Z d   Z d   Z d d  Z d   Z RS(   s8   The base class for all classes that have traitlets.
    c         O   s   t  t |   j } | t j k r0 | |   } n | |  |  } i  | _ i  | _ t | _ xZ t |   D]L } y t	 |  |  } Wn t
 k
 r qg Xt | t  rg | j |  qg qg Wt | _ | S(   N(   R   R;   R   R   Rb   t   _trait_notifiersRG   Rx   R0   R1   R2   R   RT   RU   RI   (   Ri   t   argst   kwt   new_metht   instR7   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   +  s     				c      	   O   sD   |  j    2 x* t |  D] \ } } t |  | |  q WWd  QXd  S(   N(   t   hold_trait_notificationsR   RC   (   R*   R   R   R7   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+   F  s    c         #   s  |  j  t k r d Vd Si    |  j } d       f d   } z	y | |  _ t |  _  d Vxe t   j    D]Q } t |  d |  rr t |  d |  } t |  | | t |  |  |    qr qr WWn t k
 rI} d   |  _ xQ   j	   D]C \ } } | d t
 k	 r&t |  | | d  q |  j j |  q Wi    |  n XWd | |  _ t |  _  t | t j  r|  j j d d  n  x!   j   D] } |  j |   qWXd S(   sH  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.
        Nc         S   s-   |  d k r | S| d |  d | d f Sd S(   s3   merges notifications of the form (name, old, value)i    i   i   N(   R"   (   t   previoust   current(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   merge^  s    c             s(      j  |  d  |    |  d <d  S(   Ni    (   R   (   t   a(   R   t   cache(    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   holde  s    s   _%s_validatec          W   s   d  S(   N(   R"   (   t   x(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   <lambda>q  s    i   Rq   (   Rx   RG   Rq   R#   t   keysRw   R1   RC   R   t   itemsR
   Rb   t   popRI   R   t   typest
   MethodTypeRg   R"   t   values(   R*   Rq   R   R   Rz   R   R)   Rk   (    (   R   R   sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   N  s<    			 		-		c   
      C   s_  g  } | j  |  j j | g    | j  |  j j d g    y t |  d |  } Wn n X| j |  x | D] } t |  rKt |  } t | d  } t | t	 j
  r d }	 n d }	 | |	 d k r |   qW| |	 d k r | |  qW| |	 d k r| | |  qW| |	 d k r<| | | |  qWt d   qs t d	   qs Wd  S(
   NR!   s   _%s_changedi    ii   i   i   s1   a trait changed callback must have 0-3 arguments.s*   a trait changed callback must be callable.(   t   extendR   R   R1   R3   t   callableR   R9   R   R   R   R   (
   R*   R   Rs   Rr   t	   callablest   cbt   ct   argspect   nargst   offset(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRq     s2    	
c         C   sR   | |  j  k r% g  } | |  j  | <n |  j  | } | | k rN | j |  n  d  S(   N(   R   R3   (   R*   t   handlerR   t   nlist(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   _add_notifiers  s    c         C   sQ   | |  j  k rM |  j  | } y | j |  } Wn t k
 rB qM X| | =n  d  S(   N(   R   Rf   t
   ValueError(   R*   R   R   R   Rf   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   _remove_notifiers  s    c         C   sg   | r6 t  |  } xN | D] } |  j | |  q Wn- t  |  } x | D] } |  j | |  qI Wd S(   s  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).

        Parameters
        ----------
        handler : callable
            A callable that is called when a trait changes.  Its
            signature can be handler(), handler(name), handler(name, new)
            or handler(name, old, new).
        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.
        N(   R'   R   R   (   R*   R   R   RM   t   namesR&   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRD     s    c         K   s   |  j  |   j   S(   s   Get a list of all the names of this class' traits.

        This method is just like the :meth:`trait_names` method,
        but is unbound.
        (   t   class_traitsR   (   Ri   RZ   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   class_trait_names  s    c   	      K   s   t  g  t |   D] } t | d t  r | ^ q  } t |  d k rN | Sx? | j   D]1 \ } } t |  t k	 r[ t |  | | <q[ q[ Wi  } xZ | j   D]L \ } } x= | j   D]% \ } } | | j	 |   s Pq q W| | | <q W| S(   s?  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.  This does not allow for any simple way of
        testing that a metadata name exists and has any
        value because get_metadata returns None if a metadata key
        doesn't exist.
        i   i    (
   t   dictR8   R   R   R9   R   R   R    R(   R   (	   Ri   RZ   t   membR<   t	   meta_namet	   meta_evalt   resultR   t   trait(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s    "c            s2   t  |  |       f d   |  j |   j   D S(   s   Get a dict of all the traitlets defined on this class, not a parent.

        Works like `class_traits`, except for excluding traits from parents.
        c            s7   i  |  ]- \ } } t    | d   | k	 r | |  q S(   N(   R1   R"   (   t   .0R&   R   (   t   sup(    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pys
   <dictcomp>  s   	 	(   R   R   R   (   Ri   RZ   (    (   R   sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   class_own_traits  s    c         C   s   t  t |  j | d  t  S(   s?   Returns True if the object has a trait with the specified name.N(   R   R1   R   R"   R   (   R*   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt	   has_trait"  s    c         K   s   |  j  |   j   S(   s2   Get a list of all the names of this class' traits.(   R<   R   (   R*   RZ   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   trait_names&  s    c   	      K   s   t  g  t |  j  D] } t | d t  r | ^ q  } t |  d k rQ | Sx? | j   D]1 \ } } t |  t k	 r^ t	 |  | | <q^ q^ Wi  } xZ | j   D]L \ } } x= | j   D]% \ } } | | j
 |   s Pq q W| | | <q W| S(   s  Get 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.  This does not allow for any simple way of
        testing that a metadata name exists and has any
        value because get_metadata returns None if a metadata key
        doesn't exist.
        i   i    (   R   R8   R   R   R   R9   R   R   R    R(   R   (	   R*   RZ   R   R<   R   R   R   R   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR<   *  s    "c         C   sZ   y t  |  j |  } Wn- t k
 rE t d |  j j | f   n X| j | |  Sd S(   s%   Get metadata values for trait by key.s'   Class %s does not have a trait named %sN(   R1   R   R2   R   R   R   (   R*   t	   traitnameR7   RW   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   trait_metadataN  s    c         K   sI   t  |  j j |  j f |  |  _ x! | j   D] } | j |   q. Wd S(   s;   Dynamically add trait attributes to the HasTraits instance.N(   R   R   R   R   RU   (   R*   R<   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt
   add_traitsX  s    N(   R   R   RO   R   R+   RP   RQ   R   Rq   R   R   R"   RI   RD   t   classmethodR   R   R   R   R   R<   R   R   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR;   '  s    		9	,			
"	'
			$
t   ClassBasedTraitTypec           B   s    e  Z d  Z d   Z d   Z RS(   se   
    A trait with error reporting and string -> type resolution for Type,
    Instance and This.
    c         C   s
   t  |  S(   sM   
        Resolve a string supplied for a type into an actual object.
        (   R   (   R*   t   string(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   _resolve_stringn  s    c         C   s   t  |  } t j r5 | t k r5 d | j j } n# d t |  d d !t |  f } | d  k	 r d |  j	 t
 |  |  j   | f } n d |  j	 |  j   | f } t |   d  S(   Ns   class %ss   %s (i.e. %s)i   isJ   The '%s' trait of %s instance must be %s, but a value of %s was specified.s;   The '%s' trait must be %s, but a value of %r was specified.(   R   R   R   R   R   R   t   strt   reprR"   R   R   R   R   (   R*   R   R)   t   kindR   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   t  s    #(   R   R   RO   R   R   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   h  s   	t   Typec           B   sA   e  Z d  Z e d d  Z d   Z d   Z d   Z d   Z	 RS(   s<   A trait whose value must be a subclass of a specified class.c         K   s   | t  k r' | d k r t n | } n | } | d k rc | d k sQ | t  k rZ t } qc | } n  t j |  p t | t j  s t d   n  | |  _	 t
 t |   j | |  d S(   s  Construct 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.
        s"   A Type trait must specify a class.N(   R
   R"   R   R   R   R   R   R   R   t   klassR   R   R+   (   R*   RX   R   RZ   t   new_default_value(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+     s    		!	c         C   s   t  | t j  rX y |  j |  } WqX t k
 rT t d |  j | | f   qX Xn  y t | |  j  rq | SWn n X|  j	 | |  d S(   s4   Validates that the value is a valid object instance.sJ   The '%s' trait of %s instance must be a type, but %r could not be importedN(
   R   R   R   R   t   ImportErrorR   R   R   R   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s    c         C   sZ   t  |  j t j  r! |  j } n |  j j d |  j j } d | } |  j rV | d S| S(   s$    Returns a description of the trait.t   .s   a subclass of '%s's    or None(   R   R   R   R   R   R   RY   (   R*   R   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s    
	c         C   s$   |  j    t t |   j |  d  S(   N(   t   _resolve_classesR   R   RU   (   R*   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRU     s    
c         C   s^   t  |  j t j  r- |  j |  j  |  _ n  t  |  j t j  rZ |  j |  j  |  _ n  d  S(   N(   R   R   R   R   R   RX   (   R*   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s    N(
   R   R   RO   R
   R"   R+   Rv   R   RU   R   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s   *			t   Instancec           B   sS   e  Z d  Z d Z d d d d  Z d   Z d   Z d   Z d   Z	 d   Z
 RS(   s   A 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
    c         K   s   | d k r |  j } n  | d k	 rQ t j |  sE t | t j  rQ | |  _ n t d |   | d k	 r t | t  r t d   n  | d k	 r t | t	  r t d   n  | |  _
 | |  _ t t |   j |   d S(   ss  Construct 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 True]
            Indicates whether None is allowed as a value.

        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.
        s+   The klass attribute must be a class not: %rs)   The 'kw' argument must be a dict or None.s,   The 'args' argument must be a tuple or None.N(   R"   R   R   R   R   R   R   R   R   R$   t   default_argst   default_kwargsR   R   R+   (   R*   R   R   R   RZ   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+     s    -
		c         C   s*   t  | |  j  r | S|  j | |  d  S(   N(   R   R   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s    c         C   sN   t  |  j t j  r! |  j } n |  j j } t |  } |  j rJ | d S| S(   Ns    or None(   R   R   R   R   R   R   RY   (   R*   R   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s    	c         C   s$   |  j    t t |   j |  d  S(   N(   R   R   R   RU   (   R*   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRU   "  s    
c         C   s1   t  |  j t j  r- |  j |  j  |  _ n  d  S(   N(   R   R   R   R   R   (   R*   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   &  s    c         C   sD   |  j  d  k r" |  j d  k r" d  S|  j |  j  p4 d |  j p@ i    S(   N(    (   R   R"   R   R   (   R*   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRd   *  s    N(   R   R   RO   R"   R   R+   Rv   R   RU   R   Rd   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s   .				t   ForwardDeclaredMixinc           B   s   e  Z d  Z d   Z RS(   sC   
    Mixin for forward-declared versions of Instance and Type.
    c         C   s%   |  j  j } t d j | | g   S(   s   
        Find the specified class name by looking for it in the module in which
        our this_class attribute was defined.
        R   (   RV   R   R   t   join(   R*   R   t   modname(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   5  s    (   R   R   RO   R   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   1  s   t   ForwardDeclaredTypec           B   s   e  Z d  Z RS(   s+   
    Forward-declared version of Type.
    (   R   R   RO   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   >  s   t   ForwardDeclaredInstancec           B   s   e  Z d  Z RS(   s/   
    Forward-declared version of Instance.
    (   R   R   RO   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   E  s   t   Thisc           B   s&   e  Z d  Z d Z d   Z d   Z RS(   s  A 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.
    s4   an instance of the same type as the receiver or Nonec         K   s   t  t |   j d  |  d  S(   N(   R   R   R+   R"   (   R*   RZ   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+   V  s    c         C   s6   t  | |  j  s | d  k r" | S|  j | |  d  S(   N(   R   RV   R"   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv   Y  s    (   R   R   RO   R   R+   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   L  s   	R{   c           B   s2   e  Z d  Z d   Z d   Z d   Z d   Z RS(   s'   A trait type representing a Union type.c         K   sa   | |  _  d j g  |  j  D] } | j ^ q  |  _ |  j  d j |  _ t t |   j |   d S(   s'  Construct 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.

        Notes
        -----
        Union([Float(), Bool(), Int()]) attempts to validate the provided values
        with the validation function of Float, then Bool, and finally Int.
        s    or i    N(   R|   R   R   RX   R   R{   R+   (   R*   R|   RZ   t   tt(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+   f  s    	+c         C   sG   x* |  j  D] } |  j | _ | j |  q
 Wt t |   j |  d  S(   N(   R|   RV   RU   R   R{   (   R*   R   t
   trait_type(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRU   |  s    c         C   se   xN |  j  D]C } y& | j | |  } | j |  _ | SWq
 t k
 rL q
 q
 Xq
 W|  j | |  d  S(   N(   R|   Ra   R\   R   R   (   R*   R   R)   R   Rk   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s    c         C   s;   t  | t  r# t |  j | j  St |  j | g  Sd  S(   N(   R   R{   R|   (   R*   R}   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR~     s    (   R   R   RO   R+   RU   Rv   R~   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR{   c  s
   			
t   Anyc           B   s   e  Z d  Z d Z d Z RS(   s   A trait which allows any value.s	   any valueN(   R   R   RO   R"   RX   R   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s   t   Intc           B   s2   e  Z d  Z d Z d Z e d d  Z d   Z RS(   s   An int trait.i    s   an intc         K   sP   | j  d d   |  _ | j  d d   |  _ t t |   j d | d | |  d  S(   Nt   mint   maxRX   RY   (   R   R"   R   R   R   R   R+   (   R*   RX   RY   t   kwargs(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+     s    c         C   s   t  | t  s" |  j | |  n  |  j d  k	 rk | |  j k rk t d |  j t |  |  j | f   n  |  j d  k	 r | |  j k  r t d |  j t |  |  j | f   n  | S(   Nsi   The value of the '%s' trait of %s instance should not be greater than %s, but a value of %s was specifiedsf   The value of the '%s' trait of %s instance should not be less than %s, but a value of %s was specified(	   R   t   intR   R   R"   R   R   R   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s    N(	   R   R   RO   RX   R   R
   R"   R+   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s   t   CIntc           B   s   e  Z d  Z d   Z RS(   s#   A casting version of the int trait.c         C   s,   y t  |  SWn |  j | |  n Xd  S(   N(   R   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s    (   R   R   RO   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s   t   Longc           B   s#   e  Z d  Z d Z d Z d   Z RS(   s   A long integer trait.i    s   a longc         C   s@   t  | t  r | St  | t  r, t |  S|  j | |  d  S(   N(   R   t   longR   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s
    
(   R   R   RO   RX   R   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s   t   CLongc           B   s   e  Z d  Z d   Z RS(   s,   A casting version of the long integer trait.c         C   s,   y t  |  SWn |  j | |  n Xd  S(   N(   R   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s    (   R   R   RO   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s   t   Integerc           B   s#   e  Z d  Z d Z d Z d   Z RS(   sW   An integer trait.

        Longs that are unnecessary (<= sys.maxint) are cast to ints.i    s
   an integerc         C   s{   t  | t  r | St  | t  r, t |  St j d k rg d d l m } t  | |  rg t |  Sn  |  j | |  d  S(   Nt   clii(   t   Int64(   R   R   R   t   syst   platformt   SystemR   R   (   R*   R   R)   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s    
(   R   R   RO   RX   R   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s   t   Floatc           B   s2   e  Z d  Z d Z d Z e d d  Z d   Z RS(   s   A float trait.g        s   a floatc         K   s]   | j  d t d   |  _ | j  d t d   |  _ t t |   j d | d | |  d  S(   NR   t   infR   RX   RY   (   R   t   floatR   R   R   R   R+   (   R*   RX   RY   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+     s    c         C   s   t  | t  r t |  } n  t  | t  s@ |  j | |  n  | |  j k s^ | |  j k  r t d |  j t |  |  j |  j | f   n  | S(   Nsg   The value of the '%s' trait of %s instance should be between %s and %s, but a value of %s was specified(	   R   R   R   R   R   R   R   R   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s    N(	   R   R   RO   RX   R   R
   R"   R+   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s   t   CFloatc           B   s   e  Z d  Z d   Z RS(   s%   A casting version of the float trait.c         C   s,   y t  |  SWn |  j | |  n Xd  S(   N(   R   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s    (   R   R   RO   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s   t   Complexc           B   s#   e  Z d  Z d Z d Z d   Z RS(   s   A trait for complex numbers.g        y                s   a complex numberc         C   sF   t  | t  r | St  | t t f  r2 t |  S|  j | |  d  S(   N(   R   t   complexR   R   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s
    
y                (   R   R   RO   RX   R   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s   t   CComplexc           B   s   e  Z d  Z d   Z RS(   s.   A casting version of the complex number trait.c         C   s,   y t  |  SWn |  j | |  n Xd  S(   N(   R   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv   )  s    (   R   R   RO   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   &  s   t   Bytesc           B   s#   e  Z d  Z d Z d Z d   Z RS(   s   A trait for byte strings.t    s   a bytes objectc         C   s'   t  | t  r | S|  j | |  d  S(   N(   R   t   bytesR   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv   8  s    (   R   R   RO   RX   R   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   2  s   t   CBytesc           B   s   e  Z d  Z d   Z RS(   s+   A casting version of the byte string trait.c         C   s,   y t  |  SWn |  j | |  n Xd  S(   N(   R   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv   A  s    (   R   R   RO   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   >  s   t   Unicodec           B   s#   e  Z d  Z d Z d Z d   Z RS(   s   A trait for unicode strings.u    s   a unicode stringc         C   s   t  | t j  r | St  | t  rz y | j d d  SWqz t k
 rv d } t | j | |  j t	 |     qz Xn  |  j
 | |  d  S(   Nt   asciit   stricts<   Could not decode {!r} for unicode trait '{}' of {} instance.(   R   R   t   unicode_typeR   t   decodet   UnicodeDecodeErrorR   t   formatR   R   R   (   R*   R   R)   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv   N  s    +(   R   R   RO   RX   R   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   H  s   t   CUnicodec           B   s   e  Z d  Z d   Z RS(   s'   A casting version of the unicode trait.c         C   s/   y t  j |  SWn |  j | |  n Xd  S(   N(   R   R   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv   ]  s    (   R   R   RO   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   Z  s   t
   ObjectNamec           B   sA   e  Z d  Z d Z e j r- e d    Z n	 d   Z d   Z RS(   s{   A string holding a valid object name in this version of Python.

    This does not check that the name exists in any scope.s#   a valid object identifier in Pythonc         C   s   | S(   N(    (   t   _t   s(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   l  s    c         C   sH   t  | t  rD y t |  SWqD t k
 r@ |  j | |  qD Xn  | S(   s-   In Python 2, coerce ascii-only unicode to str(   R   t   unicodeR   t   UnicodeEncodeErrorR   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt
   coerce_strp  s    c         C   sH   |  j  | |  } t | t  r4 t j |  r4 | S|  j | |  d  S(   N(   R  R   R   R   t   isidentifierR   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv   y  s    (	   R   R   RO   R   R   R   t   staticmethodR  Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR   d  s   			t   DottedObjectNamec           B   s   e  Z d  Z d   Z RS(   sF   A string holding a valid dotted object name in Python, such as A.b3._cc         C   sN   |  j  | |  } t | t  r: t j | d t r: | S|  j | |  d  S(   Nt   dotted(   R  R   R   R   R  RG   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s    $(   R   R   RO   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR    s   t   Boolc           B   s#   e  Z d  Z e Z d Z d   Z RS(   s   A boolean (True, False) trait.s	   a booleanc         C   s'   t  | t  r | S|  j | |  d  S(   N(   R   Rp   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s    (   R   R   RO   RI   RX   R   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR    s   t   CBoolc           B   s   e  Z d  Z d   Z RS(   s'   A casting version of the boolean trait.c         C   s,   y t  |  SWn |  j | |  n Xd  S(   N(   Rp   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s    (   R   R   RO   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR    s   t   Enumc           B   s,   e  Z d  Z e d  Z d   Z d   Z RS(   s0   An enum whose value must be in a given sequence.c         K   sM   | |  _  | j d t  r0 | t k r0 d  } n  t t |   j | |  d  S(   NRY   (   R   R   RI   R
   R"   R   R	  R+   (   R*   R   RX   RZ   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+     s    		c         C   s'   | |  j  k r | S|  j | |  d  S(   N(   R   R   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s    c         C   s(   d t  |  j  } |  j r$ | d S| S(   s$    Returns a description of the trait.s   any of s    or None(   R   R   RY   (   R*   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR     s    	(   R   R   RO   R
   R+   Rv   R   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR	    s   	t   CaselessStrEnumc           B   s   e  Z d  Z d   Z RS(   s4   An enum of strings where the case should be ignored.c         C   si   t  | t j  s% |  j | |  n  x- |  j D]" } | j   | j   k r/ | Sq/ W|  j | |  d  S(   N(   R   R   R   R   R   R   (   R*   R   R)   Rk   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s    (   R   R   RO   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR
    s   t	   Containerc           B   sY   e  Z d  Z d Z d Z e Z d Z d d d  Z	 d   Z
 d   Z d   Z d   Z RS(   s\   An instance of a container (list, set, etc.)

    To be subclassed by overriding klass.
    c         K   s   | d k r( t |  r( | } d } n  | d k r= d } n: t | |  j  r[ | f } n t d |  j j | f   t |  r t | t  r |   n | |  _ n% | d k	 r t d t	 |    n  t
 t |   j d |  j d | |  d S(   s  Create 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

        **metadata : any
            further keys for extensions to the Trait (e.g. config)

        s   default value of %s was %ss'   `trait` must be a Trait or None, got %sR   R   N(    (   R"   R    R   t   _valid_defaultsR:   R   R   R   t   _traitR   R   R  R+   R   (   R*   R   RX   RZ   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+     s    !		$c         C   s;   d |  j  t |  | j   t |  f } t |   d  S(   NsU   Element of the '%s' trait of %s instance must be %s, but a value of %s was specified.(   R   R   R   R   R   (   R*   R   t   elementt	   validatorR   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   element_error  s    (c         C   se   t  | |  j  r$ |  j |  } n  t t |   j | |  } | d  k rO | S|  j | |  } | S(   N(   R   t   _cast_typesR   R   R  Rv   R"   t   validate_elements(   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s    c         C   s   g  } |  j  d  k s' t |  j  t  r+ | Sx^ | D]V } y |  j  j | |  } Wn' t k
 rz |  j | | |  j   q2 X| j |  q2 W|  j |  S(   N(	   R  R"   R   R   Ra   R   R  R3   R   (   R*   R   R)   t	   validatedRk   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR    s    !c         C   sN   t  |  j t  r4 |  j |  j _ |  j j |  n  t t |   j |  d  S(   N(   R   R  R   RV   RU   R   R  (   R*   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRU     s    N(    (   R   R   RO   R"   R   R  t   SequenceTypesR  R  R+   R  Rv   R  RU   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR    s   3			t   Listc           B   sP   e  Z d  Z e Z e f Z d d d e j	 d  Z
 d   Z d   Z d   Z RS(   s   An instance of a Python list.i    c         K   s8   | |  _  | |  _ t t |   j d | d | |  d S(   s  Create 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
        R   RX   N(   t   _minlent   _maxlenR   R  R+   (   R*   R   RX   t   minlent   maxlenRZ   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+   '  s    		c         C   s8   d |  j  t |  |  j |  j | f } t |   d  S(   Ns_   The '%s' trait of %s instance must be of length %i <= L <= %i, but a value of %s was specified.(   R   R   R  R  R   (   R*   R   R)   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   length_errorK  s    %c         C   sV   t  |  } | |  j k  s* | |  j k r= |  j | |  n  t t |   j | |  S(   N(   R9   R  R  R  R   R  R  (   R*   R   R)   t   length(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR  P  s    c         C   s1   t  t |   j | |  } |  j | |  } | S(   N(   R   R  Rv   R  (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv   W  s    N(   R   R   RO   R#   R   R$   R  R"   R   t   maxsizeR+   R  R  Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR  "  s   	$		t   Setc           B   s8   e  Z d  Z e Z e e f Z d d d e	 j
 d  Z RS(   s   An instance of a Python set.i    c         K   s&   t  t |   j | | | | |  d S(   s  Create 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
        N(   R   R  R+   (   R*   R   RX   R  R  RZ   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+   c  s     N(   R   R   RO   t   setR   R$   R#   R  R"   R   R  R+   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR  ]  s   t   Tuplec           B   s8   e  Z d  Z e Z e f Z d   Z d   Z d   Z	 RS(   s   An instance of a Python tuple.c      	   O   s2  | j  d d  } t |  d k rT | d k rT t | d  rT | d } d } n  | d k ri d	 } n: t | |  j  r | f } n t d |  j j | f   g  |  _	 x< | D]4 } t | t
  r |   n | } |  j	 j |  q W|  j	 r	| d k r	d } n  t t |   j d |  j d | |  d S(
   s  Create 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, the
            `default_value` must conform to the shape and type they specify.
        RX   i   i    s   default value of %s was %sR   R   N(    (    (   R   R"   R9   R    R   R  R:   R   R   t   _traitsR   R3   R   R  R+   R   (   R*   R<   RZ   RX   R   R   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+     s     /
				c         C   s   |  j  s | St |  t |  j   k re d |  j t |  t |  j   t |  f } t |   n  g  } xj t |  j  |  D]V \ } } y | j | |  } Wn$ t k
 r |  j | | |  q~ X| j	 |  q~ Wt
 |  S(   NsT   The '%s' trait of %s instance requires %i elements, but a value of %s was specified.(   R   R9   R   R   R   R   t   zipRa   R  R3   R$   (   R*   R   R)   R   R  R   Rk   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR    s    	+c         C   sY   x< |  j  D]1 } t | t  r
 |  j | _ | j |  q
 q
 Wt t |   j |  d  S(   N(   R   R   R   RV   RU   R   R  (   R*   R   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRU     s
    (
   R   R   RO   R$   R   R#   R  R+   R  RU   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR    s   		6	t   Dictc           B   sJ   e  Z d  Z d Z d d e d  Z d   Z d   Z d   Z	 d   Z
 RS(   s   An instance of a Python dict.c         K   s*  | t  k r6 | d k	 r6 t |  s6 | } d } q6 n  | t  k rK i  } n  | d k r` d } nF t | t  r{ | f } n+ t | t  r | f } n t d |   t |  r t | t  r |   n | |  _ n% | d k	 r t d t	 |    n  | |  _
 t t |   j d t d | |  d S(   s  Create a dict trait type from a dict.

        The default value is created by doing ``dict(default_value)``,
        which creates a copy of the ``default_value``.

        trait : TraitType [ optional ]
            The type for restricting the contents of the Container. If
            unspecified, types are not checked.

        traits : Dictionary of trait types [optional]
            The type for restricting the content of the Dictionary for certain
            keys.

        default_value : SequenceType [ optional ]
            The default value for the Dict.  Must be dict, tuple, or None, and
            will be cast to a dict if not None. If `trait` is specified, the
            `default_value` must conform to the constraints it specifies.
        s   default value of Dict was %ss'   `trait` must be a Trait or None, got %sR   R   N(   R
   R"   R    R   R   R  R:   R   R  R   R   R   R"  R+   (   R*   R   R<   RX   RZ   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR+     s&    		$	c         C   s;   d |  j  t |  | j   t |  f } t |   d  S(   NsU   Element of the '%s' trait of %s instance must be %s, but a value of %s was specified.(   R   R   R   R   R   (   R*   R   R  R  R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR    s    (c         C   sA   t  t |   j | |  } | d  k r+ | S|  j | |  } | S(   N(   R   R"  Rv   R"   R  (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv     s
    c         C   s@  |  j  d  k	 rW xE |  j  D]7 } | | k r t d | |  j t |  f   q q Wn  |  j  d  k r |  j d  k s t |  j t  r | Si  } x | D] } | | } yS |  j  d  k	 r | |  j  k r |  j  | j | |  } n |  j j | |  } Wn' t k
 r$|  j	 | | |  j  q X| | | <q W|  j
 |  S(   Ns;   Missing required '%s' key for the '%s' trait of %s instance(   R   R"   R   R   R   R  R   R   Ra   R  R   (   R*   R   R)   R7   R  Rk   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR    s&    &
c         C   s   t  |  j t  r4 |  j |  j _ |  j j |  n  |  j d  k	 ry x3 |  j j   D] } |  j | _ | j |  qS Wn  t t	 |   j |  d  S(   N(
   R   R  R   RV   RU   R   R"   R   R   R"  (   R*   R   R   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRU   3  s    N(   R   R   RO   R"   R  R
   R+   R  Rv   R  RU   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR"    s   0			t
   TCPAddressc           B   s#   e  Z d  Z d Z d Z d   Z RS(   sg   A trait for an (ip, port) tuple.

    This allows for both IPv4 IP addresses as well as hostnames.
    s	   127.0.0.1i    s   an (ip, port) tuplec         C   s   t  | t  ry t |  d k ry t  | d t j  rv t  | d t  rv | d } | d k rs | d k rs | Sqv qy n  |  j | |  d  S(   Ni   i    i   i  (   R   R$   R9   R   R   R   R   (   R*   R   R)   t   port(    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv   G  s    )
(   s	   127.0.0.1i    (   R   R   RO   RX   R   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR#  >  s   t   CRegExpc           B   s   e  Z d  Z d Z d   Z RS(   s   A casting compiled regular expression trait.

    Accepts both strings and compiled regular expressions. The resulting
    attribute will be a compiled regular expression.s   a regular expressionc         C   s/   y t  j |  SWn |  j | |  n Xd  S(   N(   t   ret   compileR   (   R*   R   R)   (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyRv   X  s    (   R   R   RO   R   Rv   (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyR%  P  s   (W   RO   RP   R   R&  R   R   R    R   R   R   t
   ClassTypest   warningsR   t   ipython_genutilsR   t   ipython_genutils.py3compatR   R   t   utils.getargspecR   t   utils.importstringR   t   utils.sentinelR	   R#   R$   R  t	   frozensetR  R
   t   NoDefaultSpecifiedRm   R   R   R   R   R    R'   R(   R"   R8   R?   R   R@   RR   t   dlinkRT   R   R   t   with_metaclassR;   R   R   R   R   R   R   R   R{   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R   R  R  R  R	  R
  R  R  R  R  R"  R#  R%  (    (    (    sK   /data/av2000/mvv/env_mvv/lib/python2.7/site-packages/traitlets/traitlets.pyt   <module>#   s   				
			
	3+#&" BSX4					



a;)Vb