Файловый менеджер - Редактировать - /opt/imh-python/lib/python3.9/site-packages/traitlets/__pycache__/traitlets.cpython-39.pyc
Ðазад
a _�h)Q � @ s� d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z ddlmZ ddlmZmZmZmZ ddlmZ dd lmZ dd lmZ dd lm Z m Z m Z e e e!e"fZ#e$fZ%e j&r�dd l'm(Z( n dd l m(Z( g d �Z)eddd�Z*eddd�Z+e*Z,G dd� de-�Z.ddd�dd�Z/ddd�dd �Z0ddd �d d �Z1d d!d"�d#d$�Z2G d%d&� d&�Z3d�ddd'd(�d)d*�Z4dd+d,�d-d.�Z5G d/d0� d0�Z6G d1d2� d2�Z7e7Z8G d3d4� d4�Z9e(d5�Z:e(d6�Z;e(d7�Z<e j&�rdd8l'm=Z=m>Z> e(d9e?d:�Z@e(d;e jAd:�ZBG d<d=� d=e9e jCe:e;f �ZDG d>d?� d?�ZEdd?d@�dAdB�ZFG dCdD� dDe$�ZGG dEdF� dFeG�ZHdGdH�dIddJdK�dLdM�ZIdNdNdO�dPdQ�ZJdIdRd"�dSdT�ZKddUdV�dWdX�ZLe j(dNe jMdYe jAf dZ�ZNG d[d\� d\e9�ZOG d]dJ� dJeO�ZPG d^dR� dReO�ZQG d_dU� dUeO�ZRG d`da� daeGdb�ZSG dcdd� ddeSeHdb�ZTG dedf� dfeDe:e;f �ZUG dgdh� dheUe:e;f �ZVG didj� djeUe<e<f �ZWG dkdl� dl�ZXG dmdn� dneXeVe:e;f �ZYG dodp� dpeXeWe< �ZZG dqdr� dreUe j[e< e j[e< f �Z\G dsdt� dteDe jAe jAf �Z]G dudv� dveDe j[e jA e j[e jA f �ZAdwddddx�dydz�Z^G d{d|� d|eDe:e;f �Z_G d}d~� d~e_e:e;f �Z`e_e` ZaZbe_ZcG dd�� d�eDe:e;f �ZdG d�d�� d�ede:e;f �ZeG d�d�� d�eDefe j]efegehf f �ZiG d�d�� d�eieDefe jAf �ZjG d�d�� d�eDekekf �ZlG d�d�� d�eleDeke jAf �ZmG d�d�� d�eDe:e;f �ZnG d�d�� d�ene:e;f eDe?e jAf �ZoG d�d�� d�eDe?e?f �ZpG d�d�� d�ep�ZqG d�d�� d�eDe:e;f �ZrG d�d�� d�ere:e;f �ZsG d�d�� d�eDe:e:f �ZtG d�d�� d�ete: �ZuG d�d�� d�ete: �ZvG d�d�� d�eWe< �ZwG d�d�� d�ewe jxe< �ZxG d�d�� d�ewe jye jA �ZyG d�d�� d�ewe jze jAdYf �ZzG d�d�� d�eWd� �Z{G d�d�� d�eDe:e;f �Z|G d�d�� d�eDd�e j]d�e?f f �Z}G d�d�� d�eDe jAe jAf �Z~G d�d�� d�eDe jMdYe jAf e jMdYe jAf f �ZMdS )�a� A lightweight Traits like module. This is designed to provide a lightweight, simple, pure Python version of many of the capabilities of enthought.traits. This includes: * Validation * Type specification with defaults * Static and dynamic notification * Basic predefined types * An API that is similar to enthought.traits We don't support: * Delegation * Automatic GUI generation * A full set of trait types. Most importantly, we don't provide container traits (list, dict, tuple) that can trigger notifications if their contents change. * API compatibility with enthought.traits There are also some important difference in our design: * enthought.traits does not validate default values. We do. We choose to create this module because we need these capabilities, but we need them to be pure Python so they work in all Python implementations, including Jython and IronPython. Inheritance diagram: .. inheritance-diagram:: traitlets.traitlets :parts: 3 � )� annotationsN)� literal_eval� )�Bunch)� add_article�class_of�describe� repr_type)� getargspec�� import_item)�Sentinel)�deprecated_method� should_warn�warn)�TypeVar);�All�Any�BaseDescriptor�Bool�Bytes�CBool�CBytes�CComplex�CFloat�CInt�CLong�CRegExp�CUnicode�Callable�CaselessStrEnum�ClassBasedTraitType�Complex� Container�DefaultHandler�Dict�DottedObjectName�Enum� EventHandler�Float�ForwardDeclaredInstance�ForwardDeclaredMixin�ForwardDeclaredType� FuzzyEnum�HasDescriptors� HasTraits�Instance�Int�Integer�List�Long�MetaHasDescriptors� MetaHasTraits� ObjectName�ObserveHandler�Set� TCPAddress�This� TraitError� TraitType�Tuple�Type�Unicode� Undefined�Union�UseEnum�ValidateHandler�default�directional_link�dlink�link�observe�observe_compat�parse_notifier_name�validaterA Z traitletszA Used in Traitlets to specify that no defaults are set in kwargs r zi Used in Traitlets to listen to all types of notification or to notifications from all trait attributes. c @ s e Zd ZdS )r< N)�__name__� __module__� __qualname__� rP rP ��/root/rpmbuild/BUILDROOT/imh-python39-modules-3.9.7-92.el8.x86_64/opt/imh-python/lib/python3.9/site-packages/traitlets/traitlets.pyr< � s r< �t.Any�bool��s�returnc C s t �t| �� �S �N)�t�castrS � isidentifier�rU rP rP rQ rZ � s rZ �strc C s, z t | �W S tttfy& | Y S 0 dS )zwSafely evaluate an expression Returns original string if eval fails. Use only where types are ambiguous. N)r � NameError� SyntaxError� ValueErrorr[ rP rP rQ �_safe_literal_eval� s r` )rX rV c C s t | t�p t | t�o t| t�S )zHReturns whether the given value is an instance or subclass of TraitType.)� isinstancer= �type� issubclass)rX rP rP rQ �is_trait� s rd �+Sentinel | str | t.Iterable[Sentinel | str]zt.Iterable[t.Any]��namesrV c C sv | t u st| t�r| gS t| t�r,td��nF| r8t | v r>t gS | D ]*}t|t�sBtdt|�j� d|�d���qB| S dS )a Convert the name argument to a list of names. Examples -------- >>> parse_notifier_name([]) [traitlets.All] >>> parse_notifier_name("a") ['a'] >>> parse_notifier_name(["a", "b"]) ['a', 'b'] >>> parse_notifier_name(All) [traitlets.All] z7`names` must be either `All`, a str, or a list of strs.znames must be strings, not �(�)N)r ra r\ r � TypeErrorrb rM )rg �nrP rP rQ rK � s rK c @ sH e Zd Zddd�dd�Zddd�dd �Zd d �d d �Zd d �dd�ZdS )� _SimpleTestrR �None)�valuerV c C s || _ d S rW �rn ��selfrn rP rP rQ �__init__� s z_SimpleTest.__init__rS )�testrV c C s t || jk�S rW )rS rn )rq rs rP rP rQ �__call__� s z_SimpleTest.__call__r\ �rV c C s d| j S )Nz<SimpleTest(%r)ro �rq rP rP rQ �__repr__� s z_SimpleTest.__repr__c C s | � � S rW )rw rv rP rP rQ �__str__� s z_SimpleTest.__str__N)rM rN rO rr rt rw rx rP rP rP rQ rl � s rl zlist[tuple[str, t.Any]])�object� predicaterV c C sZ g }t | �D ]@}zt| |�}W n ty0 Y q 0 |r>||�r |�||f� q |�� |S )a 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.interface with the __provides__ attribute. )�dir�getattr�AttributeError�append�sort)ry rz �results�keyrn rP rP rQ � getmembers� s r� rm )�tuplesrV c G sf | D ]\}t |�dks tdt ��|\}}t|t�sBtdt|� ��||�� vrt|�d|����qdS )z.Validate arguments for traitlet link functions� zKEach linked traitlet must be specified as (HasTraits, 'trait_name'), not %rz%Each object must be HasTraits, not %rz has no trait N)�lenrj rX ra r/ rb �traits)r� �tup�obj� trait_namerP rP rQ �_validate_link� s � r� c @ sz e Zd ZdZdZdddddd�dd�Zdd �d d �Zejdd �d d ��Z ddd�dd�Z ddd�dd�Z dd �dd�Z dS )rH aR Link traits from different objects together so they remain in sync. Parameters ---------- source : (object / attribute name) pair target : (object / attribute name) pair transform: iterable with two callables (optional) Data transformation between source and target and target and source. Examples -------- >>> class X(HasTraits): ... value = Int() >>> src = X(value=1) >>> tgt = X(value=42) >>> c = link((src, "value"), (tgt, "value")) Setting source updates target objects: >>> src.value = 5 >>> tgt.value 5 FNrR rm ��source�target� transformrV c C sB t ||� || | _| _|r |n dd� fd \| _| _| �� d S )Nc S s | S rW rP ��xrP rP rQ �<lambda>+ � z link.__init__.<locals>.<lambda>r� )r� r� r� � _transform�_transform_invrH �rq r� r� r� rP rP rQ rr ( s z link.__init__ru c C s� zlt | jd | jd | �t| jd | jd ��� W | jd j| j| jd d� | jd j| j| jd d� n:| jd j| j| jd d� | jd j| j| jd d� 0 d S �Nr r �rg )�setattrr� r� r| r� rI �_update_target�_update_sourcerv rP rP rQ rH / s � � z link.linkc c s$ d| _ zd V W d| _ nd| _ 0 d S �NTF��updatingrv rP rP rQ �_busy_updating; s zlink._busy_updating��changerV c C s� | j r d S | �� �\ t| jd | jd | �|j�� t| jd | jd �|jkr`td| � d���W d � n1 st0 Y d S )Nr r � Broken link z5: the source value changed while updating the target.) r� r� r� r� r� �newr| r� r< �rq r� rP rP rQ r� C s �zlink._update_targetc C s� | j r d S | �� �\ t| jd | jd | �|j�� t| jd | jd �|jkr`td| � d���W d � n1 st0 Y d S )Nr r r� z5: the target value changed while updating the source.) r� r� r� r� r� r� r| r� r< r� rP rP rQ r� M s �zlink._update_sourcec C s< | j d j| j| j d d� | jd j| j| jd d� d S r� )r� � unobserver� r� r� rv rP rP rQ �unlinkW s z link.unlink)N) rM rN rO �__doc__r� rr rH � contextlib�contextmanagerr� r� r� r� rP rP rP rQ rH s rH c @ sj e Zd ZdZdZdddddd�dd�Zdd �d d �Zejdd �d d ��Z ddd�dd�Z dd �dd�Z dS )rF a� Link the trait of a source object with traits of target objects. Parameters ---------- source : (object, attribute name) pair target : (object, attribute name) pair transform: callable (optional) Data transformation between source and target. Examples -------- >>> class X(HasTraits): ... value = Int() >>> src = X(value=1) >>> tgt = X(value=42) >>> c = directional_link((src, "value"), (tgt, "value")) Setting source updates target objects: >>> src.value = 5 >>> tgt.value 5 Setting target does not update source object: >>> tgt.value = 6 >>> src.value 5 FNrR rm r� c C s6 |r|ndd� | _ t||� || | _| _| �� d S )Nc S s | S rW rP r� rP rP rQ r� ~ r� z+directional_link.__init__.<locals>.<lambda>)r� r� r� r� rH r� rP rP rQ rr } s zdirectional_link.__init__ru c C st zPt | jd | jd | �t| jd | jd ��� W | jd j| j| jd d� n | jd j| j| jd d� 0 d S r� )r� r� r� r| r� rI �_updaterv rP rP rQ rH � s �zdirectional_link.linkc c s$ d| _ zd V W d| _ nd| _ 0 d S r� r� rv rP rP rQ r� � s z directional_link._busy_updatingr� c C sV | j r d S | �� �0 t| jd | jd | �|j�� W d � n1 sH0 Y d S �Nr r )r� r� r� r� r� r� r� rP rP rQ r� � s zdirectional_link._updatec C s | j d j| j| j d d� d S r� )r� r� r� rv rP rP rQ r� � s zdirectional_link.unlink)N) rM rN rO r� r� rr rH r� r� r� r� r� rP rP rP rQ rF \ s rF c @ s\ e Zd ZU dZdZded< dZded< dddd �d d �Zddd �d d�Zddd�dd�Z dS )r a� Base descriptor class Notes ----- This implements Python's descriptor protocol. This class is the base class for all such descriptors. The only magic we use is a custom metaclass for the main :class:`HasTraits` class that does the following: 1. Sets the :attr:`name` attribute of every :class:`BaseDescriptor` instance in the class dict to the name of the attribute. 2. Sets the :attr:`this_class` attribute of every :class:`BaseDescriptor` instance in the class dict to the *class* that declared the trait. This is used by the :class:`This` trait to allow subclasses to accept superclasses for :class:`This` values. N� str | None�nameztype[HasTraits] | None� this_class�type[HasTraits]rm ��clsr� rV c C s || _ || _dS )aE Part of the initialization which may depend on the underlying HasDescriptors class. It is typically overloaded for specific types. This method is called by :meth:`MetaHasDescriptors.__init__` passing the class (`cls`) and `name` under which the descriptor has been assigned. N)r� r� �rq r� r� rP rP rQ � class_init� s zBaseDescriptor.class_init�r� rV c C s |j �| j� d S rW )�_instance_initsr~ � instance_init�rq r� rP rP rQ � subclass_init� s z BaseDescriptor.subclass_initrR �r� rV c C s dS )aL Part of the initialization which may depend on the underlying HasDescriptors instance. It is typically overloaded for specific types. This method is called by :meth:`HasTraits.__new__` and in the :meth:`BaseDescriptor.instance_init` method of descriptors holding other descriptors. NrP �rq r� rP rP rQ r� � s z BaseDescriptor.instance_init) rM rN rO r� r� �__annotations__r� r� r� r� rP rP rP rQ r � s r �G�S�T)�Literal�Self�K)rE �Vc @ s� e Zd ZU dZi Zded< dZded< dZded< dZd ed < e Z d ed < e dd d d fdd dddd d dd�dd�Z d dd�dd�Z dPd dd�dd�Z dd �d d �Zd dd�d d �ZdQd!d"dd#�d$d%�Zejdd&d'd#�d(d)��Zejd d&d*d#�d+d)��Zd,d&d-d#�d.d)�Zd!d/dd0�d1d2�Zd!d/dd0�d3d4�Zd d dd0�d5d6�Zd d dd0�d7d8�Zd9d:d;�d<d=�Zd d �d>d?�ZdRd,d d@ddAdB�dCdD�ZdSd d d dE�dFdG�Zd d ddH�dIdJ�Z d d'dK�dLdM�Z d d �dNdO�Z d S )Tr= z!A base class for all trait types.�dict[str, t.Any]�metadataFrS � allow_none� read_only� any valuer\ � info_textrR � default_valueNzTraitType[G, S]� bool | Noner� rm �rq r� r� r� �help�config�kwargsrV c K sN |t ur|| _|r|| _|dur&|| _|dur2|nd| _| jrF| j| _t|�dk�rd}t�� }|duslJ �|j j dkr�|d7 }|j }|duslJ �ql|j � d�p�d} | �dd�d } d| gt|��R } t| �r�td |� d �t|d � t| j�dk�r| j�� | _| j�|� n|| _n | j�� | _|du�r6|| jd < |du�rJ|| jd < dS )aK Declare a traitlet. If *allow_none* is True, None is a valid value in addition to any values that are normally valid. The default is up to the subclass. For most trait types, the default value for ``allow_none`` is False. If *read_only* is True, attempts to directly modify a trait attribute raises a TraitError. If *help* is a string, it documents the attribute's purpose. Extra metadata can be associated with the traitlet using the .tag() convenience method or by using the traitlet instance's .metadata dictionary. N� r r rr rM �.z metadata-tagz metadata z� was set from the constructor. With traitlets 4.1, metadata should be set using the .tag() method, e.g., Int().tag(key1='value1', key2='value2')�� stacklevelr� r� )rA r� r� r� r� r� r� �inspect� currentframe�f_code�co_name�f_back� f_globals�get�split�sortedr r �DeprecationWarningr� �copy�update) rq r� r� r� r� r� r� r� �f�mod�pkgr� rP rP rQ rr � sF � zTraitType.__init__zG | NonerT c C s | j r|dkrdS |S )a Get a value from a config string such as an environment variable or CLI arguments. Traits can override this method to define their own parsing of config strings. .. seealso:: item_from_string .. versionadded:: 5.0 rm N�r� �rq rU rP rP rQ � from_string? s zTraitType.from_stringr� c C sD | j turt�t| j �S t| d�r2t�t| �� �S t�t| j �S dS )z�The default generator for this trait Notes ----- This method is registered to HasTraits classes during ``class_init`` in the same way that dynamic defaults defined by ``@default`` are. �make_dynamic_defaultN)r� rA rX rY r� �hasattrr� r� rP rP rQ rE O s zTraitType.defaultru c C s t dtdd� t�t| j�S )zmDEPRECATED: Retrieve the static default value for this trait. Use self.default_value instead zRget_default_value is deprecated in traitlets 4.0: use the .default_value attributer� r� )r r� rX rY r� r� rv rP rP rQ �get_default_value_ s �zTraitType.get_default_valuec C s, t dtdd� | �|| j�}||j| j< |S )z<DEPRECATED: Set the static default value for the trait type.zSinit_default_value is deprecated in traitlets 4.0, and may be removed in the futurer� r� )r r� � _validater� � _trait_valuesr� �rq r� rn rP rP rQ �init_default_valuej s � z TraitType.init_default_valuer/ ztype[t.Any] | None�r� r� rV c C s� | j d usJ �z|j| j }W n� ty� |�| j �}|tu rNtdtdd� |j}z d|_| �||�}W ||_n||_0 ||j| j < |� t | j ||dd�� t � t |� Y S ty� } ztd�|�W Y d }~nd }~0 0 t � t |�S d S )NzxExplicit using of Undefined as the default value is deprecated in traitlets 5.0, and may cause exceptions in the future.r� r� TrE )r� rn �ownerrb z=Unexpected error in TraitType: default value not set properly)r� r� �KeyError�trait_defaultsrA r r� �_cross_validation_lockr� �_notify_observersr rX rY r� � Exceptionr< )rq r� r� rn rE r� �erP rP rQ r� u s: � �� z TraitType.get� type[t.Any]r� c C s d S rW rP �rq r� r� rP rP rQ �__get__� s zTraitType.__get__r� c C s d S rW rP r� rP rP rQ r� � s �HasTraits | NonezSelf | Gc C s$ |du r | S t �t| �||��S dS )aM 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. N)rX rY r� r� r� rP rP rQ r� � s r� �r� rn rV c C s� | � ||�}| jd usJ �z|j| j }W n tyB | j}Y n0 ||j| j< zt||k�}W n tyv d}Y n0 |dur�|�| j||� d S )NFT)r� r� r� r� r� rS r� � _notify_trait)rq r� rn � new_value� old_valueZsilentrP rP rQ �set� s z TraitType.setc C s$ | j rtd| j ��| �||� dS )z�Set the value of the trait by self.name for the instance. Values pass through a validation stage where errors are raised when impropper types, or types that cannot be coerced, are encountered. z The "%s" trait is read-only.N)r� r< r� r� r� rP rP rQ �__set__� s zTraitType.__set__c C sJ |d u r| j r|S t| d�r(| �||�}|jdu r>| �||�}t�t|�S )NrL F)r� r� rL r� �_cross_validaterX rY r� r� rP rP rQ r� � s zTraitType._validatec C sz | j |jv r0t| ||d��}|j| j ||�}n>t|d| j �rnd| j }t||�}t||j|d� ||| �}t�t |�S )N)�traitrn r� � _%s_validate� use @validate decorator instead.) r� �_trait_validatorsr r� r| r � __class__rX rY r� )rq r� rn Zproposal� meth_nameZcross_validaterP rP rQ r� � s � zTraitType._cross_validatezTraitType[t.Any, t.Any]rB ��otherrV c C s* t |t�rt| g|j��S t| |g�S d S rW �ra rB � trait_types�rq r rP rP rQ �__or__� s zTraitType.__or__c C s | j S rW )r� rv rP rP rQ �info� s zTraitType.infozException | Nonez t.NoReturn)r� rn �errorr rV c C s |dur�| j | f7 _ | jdur�d�dd� |j dd� D ��}|durzd�| jtd|�||j d td |j d ��f|_ n(d �| j||j d td |j d ��f|_ |�| jdu r�t||p�| �� | ��|dur�d �| jt|�|p�| �� td |��}n d �| j|�p| �� td |��}t|��dS )a� Raise a TraitError Parameters ---------- obj : HasTraits or None The instance which owns the trait. If not object is given, then an object agnostic error will be raised. value : any The value that caused the error. error : Exception (default: None) An error that was raised by a child trait. The arguments of this exception should be of the form ``(value, info, *traits)``. Where the ``value`` and ``info`` are the problem value, and string describing the expected value. The ``traits`` are a series of :class:`TraitType` instances that are "children" of this one (the first being the deepest). info : str (default: None) A description of the expected value. By default this is inferred from this trait's ``info`` method. N� of c s s | ]}t d |�V qdS )�aN)r )�.0rX rP rP rQ � <genexpr> r� z"TraitType.error.<locals>.<genexpr>r� zDThe '{}' trait of {} instance contains {} which expected {}, not {}.�anr Zther z5The '{}' trait contains {} which expected {}, not {}.z2The '{}' trait of {} instance expected {}, not {}.z#The '{}' trait expected {}, not {}.)�argsr� �join�formatr r< r r )rq r� rn r r �chainr� rP rP rQ r � sH �� �� � �zTraitType.error)r� rE rV c C s2 |dkrd}nd}t d| tdd� | j�||�S )znDEPRECATED: Get a metadata value. Use .metadata[key] or .metadata.get(key, default) instead. r� z3use the instance .help string directly, like x.helpzduse the instance .metadata dictionary directly, like x.metadata[key] or x.metadata.get(key, default)� Deprecated in traitlets 4.1, r� r� )r r� r� r� )rq r� rE �msgrP rP rQ � get_metadataA s zTraitType.get_metadata)r� rn rV c C s2 |dkrd}nd}t d| tdd� || j|< dS )z[DEPRECATED: Set a metadata key/value. Use .metadata[key] = value instead. r� z;use the instance .help string directly, like x.help = valuezLuse the instance .metadata dictionary directly, like x.metadata[key] = valuer r� r� N)r r� r� )rq r� rn r rP rP rQ � set_metadataM s zTraitType.set_metadata�r� rV c K s< t |�� ��h d��}|r,td| tdd� | j�|� | S )a Sets metadata and returns self. This allows convenient metadata tagging when initializing the trait, such as: Examples -------- >>> Int(0).tag(config=True, sync=True) <traitlets.traitlets.Int object at ...> > r� r� r� r� zcThe following attributes are set in using `tag`, but seem to be constructor keywords arguments: %s r� r� )r� �keys� intersectionr � UserWarningr� r� )rq r� Zmaybe_constructor_keywordsrP rP rQ �tagY s ��� z TraitType.tagc C s t | j�S rW )�reprr� rv rP rP rQ �default_value_reprr s z TraitType.default_value_repr)N)N)NN)N) rM rN rO r� r� r� r� r� r� rA r� rr r� rE r� r� r� rX �overloadr� r� r� r� r� r r r r r r r rP rP rP rQ r= � sF � D ' �Q r= c @ s@ e Zd ZdZddd�dd�Zddd �d d �Zd dd �dd�ZdS )�_CallbackWrapperz�An object adapting a on_trait_change callback into an observe callback. The comparison operator __eq__ is implemented to enable removal of wrapped callbacks. rR rm ��cbrV c C sH || _ t| j tj�rdnd}tt|�d �| | _| jdkrDtd��d S )N���r � z1a trait changed callback must have 0-4 arguments.)r# ra �types� MethodTyper� r �nargsr< )rq r# �offsetrP rP rQ rr � s z_CallbackWrapper.__init__ry rS r c C s, t |t�rt| j|jk�S t| j|k�S d S rW )ra r! rS r# r rP rP rQ �__eq__� s z_CallbackWrapper.__eq__r r� c C s� | j dkr| �� nv| j dkr,| �|j� n^| j dkrH| �|j|j� nB| j dkrh| �|j|j|j� n"| j dkr�| �|j|j|j|j� d S )Nr r r� � r% )r( r# r� r� �oldr� r� rP rP rQ rt � s z_CallbackWrapper.__call__N)rM rN rO r� rr r* rt rP rP rP rQ r! { s r! r" c C s t | t�r| S t| �S d S rW )ra r! )r# rP rP rQ �_callback_wrapper� s r- c s\ e Zd ZdZdddddd d�� fdd � Zddddd d �� fd d � Zd dd d�dd�Z� ZS )r5 z�A metaclass for HasDescriptors. This metaclass makes sure that any TraitType class attributes are instantiated and sets their name attribute. ztype[MetaHasDescriptors]r\ ztuple[type, ...]r� rR )�mclsr� �bases� classdict�kwdsrV c sX |� � D ]4\}}t�|�rt|t�rtdtdd� |� ||< qt� j| |||fi |��S )z Create the HasDescriptors class.�Traits should be given as instances, not types (for example, `Int()`, not `Int`). Passing types is deprecated in traitlets 4.1.r� r� ) �itemsr� �isclassrc r= r r� �super�__new__)r. r� r/ r0 r1 �k�v�r rP rQ r6 � s � zMetaHasDescriptors.__new__rm )r� r/ r0 r1 rV c s& t � j|||fi |�� | �|� dS )z-Finish initializing the HasDescriptors class.N)r5 rr � setup_class)r� r� r/ r0 r1 r9 rP rQ rr � s zMetaHasDescriptors.__init__�r� r0 rV c C sj g | _ g | _|�� D ] \}}t|t�r|�| |� qt| �D ](\}}t|t�r<|�| � | j �|� q<dS )z�Setup descriptor instance on the class This sets the :attr:`this_class` and :attr:`name` attributes of each BaseDescriptor in the class dict of the newly created ``cls`` before calling their :attr:`class_init` method. N) Z _descriptorsr� r3 ra r r� r� r� r~ )r� r0 r7 r8 �_rP rP rQ r: � s z MetaHasDescriptors.setup_class)rM rN rO r� r6 rr r: � __classcell__rP rP r9 rQ r5 � s r5 c s* e Zd ZdZd ddd�� fdd� Z� ZS )r6 zA metaclass for HasTraits.r� rm r; c s� i | _ i | _i | _i | _t� �|� | �� }t| �D �]�}zt| |�}W n t y^ Y q4Y n0 t |t �r4|| j|< |}d| }|}z |d |� |j �d � }W n ty� Y n0 |D ]H}||jv r�|j| | j|< q4||j�di �v r�|j | | j|< q4q�|jd u �o|j} t|�ttfv �rb|jd u �rb|jd u �rbt |jt��sR| �rb|j| j|< �nHt|�ttfv �r�|jd u �r�|jd u �r�t |jt��s�| �r�|j| j|< n�t|�t t fv �r�t |jt ��s�| �r�|j| j|< n�t|�t t fv �rt |jt!��s| �r|j| j|< n�t|�t"k�rNt |jt!ttt f��s@| �rN|j| j|< n\t|�t#k�rt|jd u �rtd | j|< n6t |t$��r�|j%d u �r�|j&d u �r�|j�r�d | j|< |j'| j|< q4d S )N� _%s_defaultr �_trait_default_generators)(r? � _all_trait_default_generators�_traits� _static_immutable_initial_valuesr5 r: �mror{ r| r} ra r= �indexr� r_ �__dict__r� r� r� rb r r1 �min�max�intr r) �floatr r rS r r@ r\ r rB r0 � default_args�default_kwargsrE ) r� r0 rC r� rn r� Zdefault_method_nameZ mro_trait�cZnone_okr9 rP rQ r: � s� ��� ����� �� �� ���� ���� zMetaHasTraits.setup_class)rM rN rO r� r: r= rP rP r9 rQ r6 � s r6 r� �rb �Sentinel | strr8 �rg rb rV c G s@ |s t d��|D ]"}|turt|t�st d| ��qt|| d�S )a� A decorator which can be used to observe Traits on a class. The handler passed to the decorator will be called with one ``change`` dict argument. The change dictionary at least holds a 'type' key and a 'name' key, corresponding respectively to the type of notification and the name of the attribute that triggered the notification. Other keys may be passed depending on the value of 'type'. In the case where type is 'change', we also have the following keys: * ``owner`` : the HasTraits instance * ``old`` : the old value of the modified trait attribute * ``new`` : the new value of the modified trait attribute * ``name`` : the name of the modified trait attribute. Parameters ---------- *names The str names of the Traits to observe on the object. type : str, kwarg-only The type of event to observe (e.g. 'change') z2Please specify at least one trait name to observe.z5trait names to observe must be strings or All, not %rrM )rj r ra r\ r8 )rb rg r� rP rP rQ rI 8 s rI �FuncT��funcrV c s, t t fdddddd�� fdd� }t�t|�S )aZ Backward-compatibility shim decorator for observers Use with: @observe('name') @observe_compat def _foo_changed(self, change): ... With this, `super()._foo_changed(self, name, old, new)` in subclasses will still work. Allows adoption of new observer API without breaking subclasses that override and super. rR r\ )rq �change_or_namer, r� rV c sT t |t�rt|�}n6| jj}td|� d|� d�tdd� td|||| d�}� | |�S )Nz A parent of z._zA_changed has adopted the new (traitlets 4.1) @observe(change) APIr� r� r� )rb r, r� r� r� )ra �dictr r rM r r� )rq rS r, r� r� �clsname�rR rP rQ �compatible_observerd s ��z+observe_compat.<locals>.compatible_observer)rA rX rY rP )rR rW rP rV rQ rJ V s � rJ rD c G s< | s t d��| D ]"}|turt|t�st d| ��qt| �S )a� A decorator to register cross validator of HasTraits object's state when a Trait is set. The handler passed to the decorator must have one ``proposal`` dict argument. The proposal dictionary must hold the following keys: * ``owner`` : the HasTraits instance * ``value`` : the proposed value for the modified trait attribute * ``trait`` : the TraitType instance associated with the attribute Parameters ---------- *names The str names of the Traits to validate. Notes ----- Since the owner has access to the ``HasTraits`` instance via the 'owner' key, the registered cross validator could potentially make changes to attributes of the ``HasTraits`` instance. However, we recommend not to do so. The reason is that the cross-validation of attributes may run in arbitrary order when exiting the ``hold_trait_notifications`` context, and such changes may not commute. z3Please specify at least one trait name to validate.z6trait names to validate must be strings or All, not %r)rj r ra r\ rD )rg r� rP rP rQ rL | s rL r$ �r� rV c C s t | t�std| ��t| �S )a, A decorator which assigns a dynamic default for a Trait on a HasTraits object. Parameters ---------- name The str name of the Trait on the object whose default should be generated. Notes ----- Unlike observers and validators which are properties of the HasTraits instance, default value generators are class-level properties. Besides, default generators are only invoked if they are registered in subclasses of `this_type`. :: class A(HasTraits): bar = Int() @default('bar') def get_bar_default(self): return 11 class B(A): bar = Float() # This trait ignores the default generator defined in # the base class A class C(B): @default('bar') def some_other_default(self): # This default generator should not be return 3.0 # ignored since it is defined in a # class derived from B.a.this_class. z*Trait name must be a string or All, not %r)ra r\ rj r$ )r� rP rP rQ rE � s $ rE .)�boundc @ st e Zd Zdd d�dd�Zejddddd�dd��Zejdddd �d d��Zdddd �d d�Zdddd d�dd�Zd S )r( rP rQ c C s || _ | S rW rV )rq rR rP rP rQ � _init_call� s zEventHandler._init_callrR )rR r r� rV c O s d S rW rP )rq rR r r� rP rP rQ rt � s zEventHandler.__call__�r r� rV c O s d S rW rP �rq r r� rP rP rQ rt � s c O s. t | d�r| j|i |��S | j|i |��S dS )zCPass `*args` and `**kwargs` to the handler's function if it exists.rR N)r� rR rZ r\ rP rP rQ rt � s Nz types.MethodType | EventHandler)�instr� rV c C s |d u r | S t �| j|�S rW )r& r' rR )rq r] r� rP rP rQ r� � s zEventHandler.__get__)N)rM rN rO rZ rX r rt r� rP rP rP rQ r( � s r( c @ s0 e Zd Zd dddd�dd�Zddd �d d �Zd S )r8 r� �tuple[Sentinel | str, ...]r\ rm rO c C s || _ || _d S rW )� trait_namesrb )rq rg rb rP rP rQ rr � s zObserveHandler.__init__r/ �r] rV c C s |j | | j| jd� d S )NrM )rI r_ rb �rq r] rP rP rQ r� � s z ObserveHandler.instance_initN)r� �rM rN rO rr r� rP rP rP rQ r8 � s c @ s, e Zd Zddd�dd�Zddd�dd �Zd S ) rD r^ rm rf c C s || _ d S rW �r_ )rq rg rP rP rQ rr � s zValidateHandler.__init__r/ r` c C s |� | | j� d S rW )�_register_validatorr_ ra rP rP rQ r� � s z ValidateHandler.instance_initNrb rP rP rP rQ rD � s c s6 e Zd Zddd�dd�Zdddd�� fd d � Z� ZS ) r$ r\ rm rX c C s || _ d S rW )r� �rq r� rP rP rQ rr � s zDefaultHandler.__init__r� r� r� c s t � �||� | |j| j< d S rW )r5 r� r? r� r� r9 rP rQ r� � s zDefaultHandler.class_init)rM rN rO rr r� r= rP rP r9 rQ r$ � s c s< e Zd ZdZdddd�� fdd� Zdddd�dd�Z� ZS ) r. z5The base class for all classes that have descriptors.rR r[ c s^ | d }| dd � } t t|�j}|tju r4||�}n||g| �R i |��}|j| i |�� |S r� )r5 r. r6 ry �setup_instance)r r� r� Znew_methr] r9 rP rQ r6 s zHasDescriptors.__new__rm c O s8 | d }| dd� } d|_ |j}|jD ] }||� q&dS )zD This is called **before** self.__init__ is called. r r NF)r� r r� )r r� rq r� �initrP rP rQ rf s z HasDescriptors.setup_instance)rM rN rO r� r6 rf r= rP rP r9 rQ r. � s r. )� metaclassc s� e Zd ZU ded< ded< ded< ded< ded< ded < ded < d d d d �� fdd� Zd d d d �� fdd� Zdd�dd�Zdd d�dd�Zee j d d�dd���Z e j d d�dd��Z d d d d d �d d �Z d d d!�d"d#�Zd d d$�d%d&�Zd'd(d)d d*�d+d,�Zd-d(d)d d*�d.d/�Zdrd2d3dd d4�d5d6�Zed7fd'd8d(d d9�d:d;�Zed7fd'd8d(d d9�d<d=�Zefd>d d?�d@dA�ZdBdCd dD�dEdF�Zd d dG�dHdI�Zd d d dJ�dKdL�ZedMd dNdO�dPdQ��ZedMd dRdO�dSdT��Z edMd dRdO�� fdUdV� �Z d dd?�dWdX�Z d dd?�dYdZ�Z d dd[�d\d]�Z d d d?�d^d_�Z!d d d`da�dbdc�Z"d dNd[�ddde�Z#d dRd[�dfdg�Z$dsd d d d dh�didj�Z%edMd dkdl�� fdmdn� �Z&edtdMdodkdl�dpdq��Z'� Z(S )ur/ r� r� rB zdict[str | Sentinel, t.Any]�_trait_notifiersr rS r� rA r@ rR rm r[ c sL | d }| dd � } |j �� |_i |_i |_d|_tt|�j| i |�� d S )Nr r F) rB r� r� ri r r� r5 r/ rf )r r� rq r9 rP rQ rf + s zHasTraits.setup_instancec s� |}i }|r�ddd�dd�}|| _ d| _i }|�� D ]>\}}| �|�rjt| ||� t|d || dd�||< q4|||< q4t|�t| j�@ } | D ]4}| j| �| t | |��}| � ||� ||| d < q�d | _| ` | D ]}| � || � q�zt � j |i |�� W n� t �y| } zjd d � |D �} |�� D ] \} } | �| � d | ��� �q d�| �}tdj|| jj| d�tdd� W Y d } ~ n d } ~ 0 0 d S )Nr rm r� c S s d S rW rP )r� rP rP rQ �ignoreC s z"HasTraits.__init__.<locals>.ignoreTr� �r� r, r� r� rb r� Fc S s g | ] }t |��qS rP )r )r �argrP rP rQ � <listcomp>e r� z&HasTraits.__init__.<locals>.<listcomp>�=z, z�Passing unrecognized arguments to super({classname}).__init__({arg_s}). {error} This is deprecated in traitlets 4.2.This error will be raised in a future release of traitlets.)�arg_s� classnamer r� r� )� notify_changer� r3 � has_traitr� r r� rA r� r| � set_traitr5 rr rj r~ r r r r rM r� )rq r r� Z super_argsZ super_kwargsrj �changesr� rn �changedr� Z arg_s_listr7 r8 ro r9 rP rQ rr 9 sV � ��zHasTraits.__init__ru c C s4 | j �� }i |d< i |d< | j�� |d< d|d< |S )Nri r r� Fr� )rE r� r� )rq �drP rP rQ � __getstate__v s zHasTraits.__getstate__)�staterV c C sX |� � | _| j}t|�D ]:}zt||�}W n ty< Y q0 t|t�r|�| � qd S rW ) r� rE r r{ r| r} ra r( r� )rq rx r� r� rn rP rP rQ � __setstate__� s zHasTraits.__setstate__c c s4 | j rdV dS zd| _ dV W d| _ nd| _ 0 dS )z� A contextmanager for running a block with our cross validation lock set to True. At the end of the block, the lock's value is restored to its value prior to entering the block. NTF)r� rv rP rP rQ �cross_validation_lock� s z HasTraits.cross_validation_lockc # s� | j rdV dS i � dddd�dd��ddd �� �fd d � }�zzR|| _d | _ dV t� �� �D ].}t| j|�}|�| t| |��}| �||� q`W n� t�y } ztd d� | _� � � D ]L\}}|ddd� D ]4}|j dkr�|j t ur�| �||j � q�| j �|� q�q�i � |�W Y d}~n d}~0 0 W d| _ | `� �� D ] }|D ]}| �|� �q>�q6n2d| _ | `� �� D ] }|D ]}| �|� �qp�qh0 dS )aH 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. Nzlist[Bunch] | Noner z list[Bunch])� past_changesr� rV c S sJ | du r|gS | d d dkr8|j dkr8|j| d d< n | �|� | S dS )z5Merges the provided change with the last if possible.Nr$ rb r� r� )rb r� r~ )r{ r� rP rP rQ �compress� s z4HasTraits.hold_trait_notifications.<locals>.compressrm r� c s | j }�� �|�| �� |< d S rW )r� r� )r� r� ��cacher| rP rQ �hold� s z0HasTraits.hold_trait_notifications.<locals>.holdTc S s d S rW rP r� rP rP rQ r� � r� z4HasTraits.hold_trait_notifications.<locals>.<lambda>r$ r� F)r� rq �listr r| r r� rs r< r3 rb r, rA r� �pop�values)rq r r� r� rn r� rt r� rP r} rQ �hold_trait_notifications� sD � z"HasTraits.hold_trait_notificationsr\ )r� r� r� rV c C s | � t|||| dd�� d S )Nr� rk )rq r )rq r� r� r� rP rP rQ r� � s ��zHasTraits._notify_traitr r� c C s | � |�S )z"Notify observers of a change event)r� r� rP rP rQ rq � s zHasTraits.notify_change)�eventrV c C sh t |t�st|�}|d |d }}g }|| jv rj|�| j�|i ��|g �� |�| j�|i ��tg �� t| jv r�|�| j�ti ��|g �� |�| j�ti ��tg �� d| }|d dk�rt| |��rt| j|�}t |t ��st || j|d� t| |�}||v�r|� t |�� |D ]F}t |t ��r4|j}n$t |t��rX|jdu�rXt| |j�}||� �q dS )z Notify observers of any eventr� rb z _%s_changedr� z$use @observe and @unobserve instead.N)ra r ri �extendr� r r� r| r r8 r r~ r- r! rt r( r� ) rq r� r� rb Z callables� magic_name� class_valuer# rL rP rP rQ r� � s: � zHasTraits._notify_observerszt.Callable[..., t.Any]rN �str | Sentinel)�handlerr� rb rV c C sd || j vr g }||i| j |< n0|| j | vr@g }|| j | |< n| j | | }||vr`|�|� d S rW )ri r~ )rq r� r� rb ZnlistrP rP rQ �_add_notifiers" s zHasTraits._add_notifiersz t.Callable[..., t.Any] | Nonec C sF z.|d u r| j | |= n| j | | �|� W n ty@ Y n0 d S rW )ri �remover� )rq r� r� rb rP rP rQ �_remove_notifiers1 s zHasTraits._remove_notifiersNFzEventHandler | NonezSentinel | str | None)r� r� r� rV c C sH t dtdd� |du rt}|r2| jt|�|d� n| jt|�|d� dS )a� DEPRECATED: Setup a handler to be called when a trait changes. This is used to setup dynamic notifications of trait changes. Static handlers can be created by creating methods on a HasTraits subclass with the naming convention '_[traitname]_changed'. Thus, to create static handler for the trait 'a', create the method _a_changed(self, name, old, new) (fewer arguments can be used, see below). If `remove` is True and `handler` is not specified, all change handlers for the specified name are uninstalled. Parameters ---------- handler : callable, None A callable that is called when a trait changes. Its signature can be handler(), handler(name), handler(name, new), handler(name, old, new), or handler(name, old, new, self). name : list, str, None If None, the handler will apply to all traits. If a list of str, handler will apply to all names in the list. If a str, the handler will apply just to that name. remove : bool If False (the default), then install the handler. If True then unintall it. zCon_trait_change is deprecated in traitlets 4.1: use observe insteadr� r� Nr� )r r� r r� r- rI )rq r� r� r� rP rP rQ �on_trait_change< s !�zHasTraits.on_trait_changer� re )r� rg rb rV c C s t |�D ]}| �|||� qdS )a Setup a handler to be called when a trait changes. This is used to setup dynamic notifications of trait changes. Parameters ---------- handler : callable A callable that is called when a trait changes. Its signature should be ``handler(change)``, where ``change`` is a dictionary. The change dictionary at least holds a 'type' key. * ``type``: the type of notification. Other keys may be passed depending on the value of 'type'. In the case where type is 'change', we also have the following keys: * ``owner`` : the HasTraits instance * ``old`` : the old value of the modified trait attribute * ``new`` : the new value of the modified trait attribute * ``name`` : the name of the modified trait attribute. names : list, str, All If names is All, the handler will apply to all traits. If a list of str, handler will apply to all names in the list. If a str, the handler will apply just to that name. type : str, All (default: 'change') The type of notification to filter by. If equal to All, then all notifications are passed to the observe handler. N)rK r� �rq r� rg rb r� rP rP rQ rI i s zHasTraits.observec C s t |�D ]}| �|||� qdS )a� Remove a trait change handler. This is used to unregister handlers to trait change notifications. Parameters ---------- handler : callable The callable called when a trait attribute changes. names : list, str, All (default: All) The names of the traits for which the specified handler should be uninstalled. If names is All, the specified handler is uninstalled from the list of notifiers corresponding to all changes. type : str or All (default: 'change') The type of notification to filter by. If All, the specified handler is uninstalled from the list of notifiers corresponding to all types. N)rK r� r� rP rP rQ r� � s zHasTraits.unobservez str | t.AnyrX c C s4 |t u ri | _n z | j|= W n ty. Y n0 dS )zRemove trait change handlers of any type for the specified name. If name is not specified, removes all trait notifiers.N)r ri r� re rP rP rQ � unobserve_all� s zHasTraits.unobserve_allzt.Callable[..., None]ztuple[str | Sentinel, ...])r� rg rV c C sZ |D ]<}d| }t | |�rt| j|�}t|t�st|| j|d� q|D ]}|| j|< qFdS )a� Setup a handler to be called when a trait should be cross validated. This is used to setup dynamic notifications for cross-validation. If a validator is already registered for any of the provided names, a TraitError is raised and no new validator is registered. Parameters ---------- handler : callable A callable that is called when the given trait is cross-validated. Its signature is handler(proposal), where proposal is a Bunch (dictionary with attribute access) with the following attributes/keys: * ``owner`` : the HasTraits instance * ``value`` : the proposed value for the modified trait attribute * ``trait`` : the TraitType instance associated with the attribute names : List of strings The names of the traits that should be cross-validated r� r N)r� r| r ra rD r r )rq r� rg r� r� r� rP rP rQ rd � s �z HasTraits._register_validator)r� rV c K s\ | j }d|ji}t|d�r$|j|d< |�|� t|j|f|�| _ |�� D ]}|�| � qHdS )z;Dynamically add trait attributes to the HasTraits instance.rN rO N) r rN r� rO r� rb rM r� r� )rq r� r� �attrsr� rP rP rQ � add_traits� s zHasTraits.add_traits)r� rn rV c C s< | j }| �|�s&td|j� d|� ���t||��| |� dS )z>Forcibly sets trait attribute, including read-only attributes.�Class � does not have a trait named N)r rr r< rM r| r� )rq r� rn r� rP rP rQ rs � s zHasTraits.set_traitr� � list[str])r� r� rV c K s t | jf i |���S )z�Get a list of all the names of this class' traits. This method is just like the :meth:`trait_names` method, but is unbound. )r� � class_traits�r� r� rP rP rQ �class_trait_names� s zHasTraits.class_trait_namesz"dict[str, TraitType[t.Any, t.Any]]c K st | j �� }t|�dkr|S i }|�� D ]H\}}|�� D ].\}}t|�sNt|�}||j�|d��s6 q&q6|||< q&|S )a� Get a ``dict`` of all the traits of this class. The dictionary is keyed on the name and the values are the TraitType objects. This method is just like the :meth:`traits` method, but is unbound. The TraitTypes returned don't know anything about the values that the various HasTrait's instances are holding. The metadata kwargs allow functions to be passed in which filter traits based on metadata values. The functions should take a single value as an argument and return a boolean. If any function returns False, then the trait is not included in the output. If a metadata key doesn't exist, None will be passed to the function. r N�rA r� r� r3 �callablerl r� r� )r� r� r� �resultr� r� � meta_name� meta_evalrP rP rQ r� � s zHasTraits.class_traitsc s, t | | �� � fdd�| jf i |���� D �S )z�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 s& i | ] \}}t � |d �|ur||�qS rW �r| )r rk rX ��suprP rQ � <dictcomp> s �z.HasTraits.class_own_traits.<locals>.<dictcomp>)r5 r� r3 r� r9 r� rQ �class_own_traits s �zHasTraits.class_own_traitsc C s || j v S )z?Returns True if the object has a trait with the specified name.)rA re rP rP rQ rr s zHasTraits.has_traitc C s || j v S )a) Returns True if the specified trait has a value. This will return false even if ``getattr`` would return a dynamically generated default value. These default values will be recognized as existing only after they have been generated. Example .. code-block:: python class MyClass(HasTraits): i = Int() mc = MyClass() assert not mc.trait_has_value("i") mc.i # generates a default value assert mc.trait_has_value("i") )r� re rP rP rQ �trait_has_value$ s zHasTraits.trait_has_valuer c s � fdd�� j f i |��D �S )a� A ``dict`` of trait names and their values. The metadata kwargs allow functions to be passed in which filter traits based on metadata values. The functions should take a single value as an argument and return a boolean. If any function returns False, then the trait is not included in the output. If a metadata key doesn't exist, None will be passed to the function. Returns ------- A ``dict`` of trait names and their values. Notes ----- Trait values are retrieved via ``getattr``, any exceptions raised by traits or the operations they may trigger will result in the absence of a trait value in the result ``dict``. c s i | ]}|t � |��qS rP r� )r r� rv rP rQ r� O r� z*HasTraits.trait_values.<locals>.<dictcomp>rc �rq r� rP rv rQ � trait_values; s zHasTraits.trait_valuesc C s> d| }|| j v r t| |�S || jj v r4t| j|�S | j| S )z�Return default generator for a given trait Walk the MRO to resolve the correct default generator according to inheritance. r> )rE r| r r@ )rq r� � method_namerP rP rQ � _get_trait_default_generatorQ s z&HasTraits._get_trait_default_generatorzdict[str, t.Any] | Sentinel)rg r� rV c O s� |D ]*}| � |�std|� dt| �j� d���qt|�dkrbt|�dkrbt�t| �|d �| ��S | j f i |��}|� |� i }|D ]}| �|�| �||< q�|S )z�Return a trait's default value or a dictionary of them Notes ----- Dynamically generated default values may depend on the current state of the object.�'z' is not a trait of 'z ' instancesr r ) rr r< rb rM r� rX rY r r� r_ r� )rq rg r� rk r_ �defaultsrP rP rQ r� ] s zHasTraits.trait_defaultsc K s t | jf i |���S )z2Get a list of all the names of this class' traits.)r� r� r� rP rP rQ r_ s s zHasTraits.trait_namesc K st | j �� }t|�dkr|S i }|�� D ]H\}}|�� D ].\}}t|�sNt|�}||j�|d��s6 q&q6|||< q&|S )a� Get a ``dict`` of all the traits of this class. The dictionary is keyed on the name and the values are the TraitType objects. The TraitTypes returned don't know anything about the values that the various HasTrait's instances are holding. The metadata kwargs allow functions to be passed in which filter traits based on metadata values. The functions should take a single value as an argument and return a boolean. If any function returns False, then the trait is not included in the output. If a metadata key doesn't exist, None will be passed to the function. r Nr� )rq r� r� r� r� r� r� r� rP rP rQ r� w s zHasTraits.traits)� traitnamer� rE rV c C s� zt | j|�}W n> tyN } z&td| jj� d|� ��|�W Y d}~n d}~0 0 d| d }t| |�r�|t | |�v r�t | |��||�S |j�||�S dS )z%Get metadata values for trait by key.r� r� Nr< � _metadata)r| r r} r< rM r� r� r� )rq r� r� rE r� r� � metadata_namerP rP rQ �trait_metadata� s �� zHasTraits.trait_metadatazdict[str, EventHandler]r� c s& t | | �� � fdd�| �|��� D �S )z�Get a dict of all event handlers defined on this class, not a parent. Works like ``event_handlers``, except for excluding traits from parents. c s& i | ] \}}t � |d �|ur||�qS rW r� )r rk r� r� rP rQ r� � s �z4HasTraits.class_own_trait_events.<locals>.<dictcomp>)r5 �eventsr3 )r� r� r9 r� rQ �class_own_trait_events� s �z HasTraits.class_own_trait_eventsr� c C sn i }t | �D ]\\}}t|t�r |du r0|||< q ||jv rD|||< q t|d�r | jf i |j��r |||< q |S )a� Get a ``dict`` of all the event handlers of this class. Parameters ---------- name : str (default: None) The name of a trait of this class. If name is ``None`` then all the event handlers of this class will be returned instead. Returns ------- The event handlers associated with a trait name, or all event handlers. N�tags)r� ra r( r_ r� r� )r� r� r� r7 r8 rP rP rQ � trait_events� s zHasTraits.trait_events)NNF)N)N))rM rN rO r� rf rr rw ry �propertyr� r� rz r� r� rq r� r� r� r� r rI r� r� rd r� rs � classmethodr� r� r� rr r� r� r� r� r_ r� r� r� r� r= rP rP r9 rQ r/ " sj = @ + �0�%� $ ! r/ c @ s e Zd ZdZddd�dd�ZdS )r! ze A trait with error reporting and string -> type resolution for Type, Instance and This. r\ rR ��stringrV c C s t |�S )zM Resolve a string supplied for a type into an actual object. r )rq r� rP rP rQ �_resolve_string� s z#ClassBasedTraitType._resolve_stringN�rM rN rO r� r� rP rP rP rQ r! � s r! c s, e Zd ZdZejr�ejd,ddddddd d d d � d d��Zejd-ddddddd d d d � dd��Zejd.ddddddd d d d � dd��Zejd/ddddddd d d d � dd��Zedddddfd d dddd d d d�� fd d� Zd d d d �d d �Z d!d"�d#d$�Z d d d%�d&d'�Z d d"�d(d)�Z d!d"�d*d+�Z � ZS )0r? z<A trait whose value must be a subclass of a specified class..zType[type, type]zSentinel | None | strz None | str�Literal[False]r� r� � t.Any | NonerR rm ) rq r� �klassr� r� r� r� r� rV c K s d S rW rP �rq r� r� r� r� r� r� r� rP rP rQ rr � s z Type.__init__z Type[type | None, type | None]� Literal[True]c K s d S rW rP r� rP rP rQ rr � s z Type[S, S]r� c K s d S rW rP r� rP rP rQ rr s zType[S | None, S | None]zS | Nonec K s d S rW rP r� rP rP rQ rr s NFrS )r� r� r� r� r� r� r� rV c s� |t u r|du rtn|}n|}|du r@|du s6|t u r<t}n|}t�|�s\t|t�s\td��|| _t� j |f||||d�|�� dS )a^ 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. **kwargs extra kwargs passed to `ClassBasedTraitType` Nz"A Type trait must specify a class.)r� r� r� r� ) rA ry r� r4 ra r\ r< r� r5 rr ) rq r� r� r� r� r� r� r� Znew_default_valuer9 rP rQ rr s( #���r� r� c C s� t |t�r^z| �|�}W nD ty\ } z,td| j� d|� d|�d��|�W Y d}~n d}~0 0 z t|| j�rzt� t |�W S W n t y� Y n0 | � ||� dS )z4Validates that the value is a valid object instance.zThe '� ' trait of z instance must be a type, but z could not be importedN) ra r\ r� � ImportErrorr< r� rc r� rX rY r� r� r �rq r� rn r� rP rP rQ rL W s" ��� z Type.validater\ ru c C sB t | jt�r| j}n| jjd | jj }d| }| jr>|d S |S )�#Returns a description of the trait.r� za subclass of '%s'� or None)ra r� r\ rN rM r� )rq r� r� rP rP rQ r i s z Type.infor� c C s | � � d S rW ��_resolve_classesr� rP rP rQ r� t s zType.instance_initc C s8 t | jt�r| �| j�| _t | jt�r4| �| j�| _d S rW )ra r� r\ r� r� rv rP rP rQ r� y s zType._resolve_classesc C s> | j }|d usJ �t|t�r$t|�S t|j� d|j� ��S d S )Nr� )r� ra r\ r rN rM rp rP rP rQ r s zType.default_value_repr)......)......)......)......)rM rN rO r� rX � TYPE_CHECKINGr rr rA rL r r� r� r r= rP rP r9 rQ r? � s\ �" �" �" �"�"< r? c sL e Zd ZU dZdZded< ejr�ejd1dddd d d d d dd� dd��Z ejd2dddd dd d d dd� dd��Z ejd3dd dd d d d d dd� dd��Z ejd4dd dd dd d d dd� dd��Z d5ddd dd d d dd�� fd d� Z d d d d �d d �Z d!d"�d#d$�Z d dd%�d&d'�Z dd"�d(d)�Z d d"�d*d+�Zd!d"�d,d-�Zd!d d.�d/d0�Z� ZS )6r0 z�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 Nzstr | type[T] | Noner� .z Instance[T]ztype[T]ztuple[t.Any, ...] | Nonezdict[str, t.Any] | Noner� r� r� rR rm ) rq r� r �kwr� r� r� r� rV c K s d S rW rP �rq r� r r� r� r� r� r� rP rP rQ rr � s zInstance.__init__zInstance[T | None]r� c K s d S rW rP r� rP rP rQ rr � s zInstance[t.Any]c K s d S rW rP r� rP rP rQ rr � s zInstance[t.Any | None]c K s d S rW rP r� rP rP rQ rr � s FrS )r� r r� r� r� r� r� rV c s� |du r| j }|dur2t�|�s*t|t�r2|| _ n td| ��|durXt|t�sXtd��|durrt|t�srtd��|| _|| _ t � j f |||d�|�� dS )a� 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 False ] Indicates whether None is allowed as a value. **kwargs Extra kwargs passed to `ClassBasedTraitType` Notes ----- If both ``args`` and ``kw`` are None, then the default value is None. If ``args`` is a tuple and ``kw`` is a dict, then the default is created as ``klass(*args, **kw)``. If exactly one of ``args`` or ``kw`` is None, the None is replaced by ``()`` or ``{}``, respectively. Nz+The klass attribute must be a class not: %rz)The 'kw' argument must be a dict or None.z,The 'args' argument must be a tuple or None.)r� r� r� ) r� r� r4 ra r\ r< rT �tuplerJ rK r5 rr r� r9 rP rQ rr � s & �T | Noner� c C sH | j d usJ �| jr |d u r |S t|| j �r8t�t|�S | �||� d S rW )r� r� ra rX rY r� r r� rP rP rQ rL s zInstance.validater\ ru c C s6 t | jt�rt| j�}n td| j�}| jr2|d7 }|S )Nr r� )ra r� r\ r r r� )rq r� rP rP rQ r s z Instance.infor� c C s | � � d S rW r� r� rP rP rQ r� s zInstance.instance_initc C s t | jt�r| �| j�| _d S rW )ra r� r\ r� rv rP rP rQ r� s zInstance._resolve_classesc C sB | j d u r| jd u rd S | jd us&J �| j| j p2di | jp<i ��S )NrP )rJ rK r� rv rP rP rQ r� s z Instance.make_dynamic_defaultc C s t | �� �S rW )r r� rv rP rP rQ r ! s zInstance.default_value_reprrT c C s t �tt|��S rW )rX rY r� r` r� rP rP rQ r� $ s zInstance.from_string)......)......)......)......)NNNFNN)rM rN rO r� r� r� rX r� r rr rL r r� r� r� r r� r= rP rP r9 rQ r0 � sb �" �" �" �" �"8 r0 c @ s e Zd ZdZddd�dd�ZdS )r+ zC Mixin for forward-declared versions of Instance and Type. r\ rR r� c C s | j j}td�||g��S )z� Find the specified class name by looking for it in the module in which our this_class attribute was defined. r� )r� rN r r )rq r� �modnamerP rP rQ r� - s z$ForwardDeclaredMixin._resolve_stringNr� rP rP rP rQ r+ ( s r+ c @ s e Zd ZdZdS )r, z+ Forward-declared version of Type. N�rM rN rO r� rP rP rP rQ r, 6 s r, c @ s e Zd ZdZdS )r* z/ Forward-declared version of Instance. Nr� rP rP rP rQ r* < s r* c s> e Zd ZdZdZddd�� fdd� Zdddd �d d �Z� ZS ) r; a 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. z4an instance of the same type as the receiver or NonerR rm �r� rV c s t � jdi |�� d S )N)N�r5 rr �rq r� r9 rP rQ rr L s z This.__init__r� r� c C s6 | j d usJ �t|| j �s"|d u r&|S | �||� d S rW )r� ra r r� rP rP rQ rL O s z This.validate)rM rN rO r� r� rr rL r= rP rP r9 rQ r; B s r; c s� e Zd ZdZdddd�� fdd� Zd ddd�� fd d � Zd d dd �� fdd� Zddd�dd�Zdddd�dd�Zdd d�dd�Z ddd�� fd d � Z � Z S ) rB z'A trait type representing a Union type.rR rm )r r� rV c s8 t |�| _d�dd� | jD ��| _t� jf i |�� dS )a� 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. **kwargs Extra kwargs passed to `TraitType` Notes ----- Union([Float(), Bool(), Int()]) attempts to validate the provided values with the validation function of Float, then Bool, and finally Int. Parsing from string is ambiguous for container types which accept other collection-like literals (e.g. List accepting both `[]` and `()` precludes Union from ever parsing ``Union([List(), Tuple()])`` as a tuple; you can modify behaviour of too permissive container traits by overriding ``_literal_from_string_pairs`` in subclasses. Similarly, parsing unions of numeric types is only unambiguous if types are provided in order of increasing permissiveness, e.g. ``Union([Int(), Float()])`` (since floats accept integer-looking values). z or c S s g | ] }|� � �qS rP )r )r �ttrP rP rQ rm z r� z"Union.__init__.<locals>.<listcomp>N)r� r r r� r5 rr )rq r r� r9 rP rQ rr ] s zUnion.__init__Nr� c s4 t � �|�}| jD ] }|tu r*|�|�}q q0q|S rW )r5 rE r rA )rq r� rE r� r9 rP rQ rE } s z Union.defaultr� r� r� c s. t | j�D ]}|�|d � q t� �||� d S rW )�reversedr r� r5 )rq r� r� � trait_typer9 rP rQ r� � s zUnion.class_initr� r� c C s t | j�D ]}|�|� q d S rW )r� r r� )rq r� r� rP rP rQ r� � s zUnion.subclass_initr� c C s� |j �z | jD ]b}zF|�||�}| jd urBt|d| j d |j� |W W d � S tyn Y qY q0 qW d � n1 s�0 Y | �||� d S )Nr< r� )rz r r� r� r� r� r< r )rq r� rn r� r8 rP rP rQ rL � s *zUnion.validater c C s0 t |t�rt| j|j �S tg | j�|��S d S rW r r rP rP rQ r � s z Union.__or__r\ rT c sP | j D ]<}z |�|�}|�d |�W S ttfy@ Y qY q0 qt� �|�S rW )r r� rL r< r_ r5 )rq rU r� r8 r9 rP rQ r� � s zUnion.from_string)N) rM rN rO r� rr rE r� r� rL r r� r= rP rP r9 rQ rB Z s rB c @ s6 e Zd ZU dZej�rejd%dddd�d ddddddd d �d d ��Zejd&dddd�d dd ddddd d �dd ��Zejd'ddddd�d ddddddd d�dd ��Zd(ddddd�d ddddddd d�dd �Zejd dd d�dd��Zejdddd�d d��Zddd d�d d�ZdZ de d < d Z d!Z dd d"�d#d$�Z dS ))r z A trait which allows any value..�r� r� r� rR r� r� r� r� rm r� c K s d S rW rP �rq r� r� r� r� r� r� rP rP rQ rr � s z Any.__init__r� c K s d S rW rP r� rP rP rQ rr � s FN)r� r� r� r� �Literal[True, False])rq r� r� r� r� r� r� rV c K s d S rW rP �rq r� r� r� r� r� r� rP rP rQ rr � s r� rS c K s d S rW rP r� rP rP rQ rr � s r� r� c C s d S rW rP r� rP rP rQ r� � s z Any.__get__c C s d S rW rP r� rP rP rQ r� � s z t.Any | Anyc C s d S rW rP r� rP rP rQ r� � s r� Tr� r� c C s d S rW rP r� rP rP rQ r� � s zAny.subclass_init).).).).)rM rN rO r� rX r� r rr r� r� r� r� r� r� rP rP rP rQ r � sP ��" ��" ��" �� r z'Int[t.Any, t.Any] | Float[t.Any, t.Any])r� r� rn rV c C s� | j dur>|| j k r>td| j� dt|�� d| j � d|� d� ��| jdur||| jkr|td| j� dt|�� d| j� d|� d� ��|S )z� Validate that a number to be applied to a trait is between bounds. If value is not between min_bound and max_bound, this raises a TraitError with an error message appropriate for this trait. NzThe value of the 'r� z" instance should not be less than �, but a value of z was specifiedz% instance should not be greater than )rF r< r� r rG )r� r� rn rP rP rQ �_validate_bounds� s" ������r� c s� e Zd ZdZdZdZejd%ddddd d d d d �dd��Zejd&ddddd d d d d �dd��Ze ddddfd ddd d d d d�� fdd� Zd d dd�dd �Z d dd �d d �Z d!d d"�d#d$�Z � Z S )'r1 z An int trait.r zan int.z Int[int, int]zint | Sentinelr� r� r� r� rR rm r� c K s d S rW rP r� rP rP rQ rr s z Int.__init__zInt[int | None, int | None]zint | Sentinel | Noner� c K s d S rW rP r� rP rP rQ rr + s FNrS )r� r� r� r� r� r� rV c s> |� dd �| _|� dd �| _t� jf |||||d�|�� d S )NrF rG �r� r� r� r� r� )r� rF rG r5 rr r� r9 rP rQ rr 7 s ��r� r� c C s* t |t�s| �||� t�tt| ||��S rW )ra rH r rX rY r� r� r� rP rP rQ rL K s z Int.validater\ rT c C s* | j r|dkrt�td �S t�tt|��S �Nrm )r� rX rY r� rH r� rP rP rQ r� P s zInt.from_stringr� r� c C s d S rW rP r� rP rP rQ r� U s zInt.subclass_init).....).....�rM rN rO r� r� r� rX r rr rA rL r� r� r= rP rP r9 rQ r1 s4 � � � r1 c @ s� e Zd ZdZejrxejdddddddd d d �d d ��Zejdddddddd d d �dd ��Zdddddddd d d �dd �Zd d dd�dd�ZdS ) r z#A casting version of the int trait..zCInt[int, t.Any]zt.Any | Sentinelr� r� r� r� rR rm r� c K s d S rW rP r� rP rP rQ rr ^ s z CInt.__init__zCInt[int | None, t.Any]zt.Any | Sentinel | Noner� c K s d S rW rP r� rP rP rQ rr j s rS c K s d S rW rP r� rP rP rQ rr v s r� r� c C s@ z t |�}W n ty* | �||� Y n0 t�tt| ||��S rW )rH r� r rX rY r� r� r� rP rP rQ rL � s z CInt.validateN).....).....).....� rM rN rO r� rX r� r rr rL rP rP rP rQ r Y s. � � � r c s� e Zd ZdZdZdZejd$ddddd d d d d �dd��Zejd%ddddd d d d d �dd��Ze ddddfddddd d d d d �� fdd� Zd d dd�dd�Z d dd �d d �Z d d d!�d"d#�Z � Z S )&r) zA float trait.g za float.zFloat[float, int | float]zfloat | Sentinelr� r� r� r� rR rm r� c K s d S rW rP r� rP rP rQ rr � s zFloat.__init__z%Float[int | None, int | float | None]zfloat | Sentinel | Noner� c K s d S rW rP r� rP rP rQ rr � s FNrS c sH |� dtd� �| _|� dtd��| _t� jf |||||d�|�� d S )NrF �infrG r� )r� rI rF rG r5 rr r� r9 rP rQ rr � s ��r� r� c C s< t |t�rt|�}t |t�s(| �||� t�tt| ||��S rW )ra rH rI r rX rY r� r� r� rP rP rQ rL � s zFloat.validater\ rT c C s* | j r|dkrt�td �S t�tt|��S r� )r� rX rY r� rI r� rP rP rQ r� � s zFloat.from_stringr� r� c C s d S rW rP r� rP rP rQ r� � s zFloat.subclass_init).....).....r� rP rP r9 rQ r) � s4 � � �"r) c @ s� e Zd ZdZejrxejddddddddd d �d d ��Zejdd ddddddd d �dd ��Zdd ddddddd d �dd �Zdddd�dd�ZdS )r z%A casting version of the float trait..zCFloat[float, t.Any]rR r� r� r� r� rm r� c K s d S rW rP r� rP rP rQ rr � s zCFloat.__init__zCFloat[float | None, t.Any]r� c K s d S rW rP r� rP rP rQ rr � s rS c K s d S rW rP r� rP rP rQ rr � s r� r� c C s@ z t |�}W n ty* | �||� Y n0 t�tt| ||��S rW )rI r� r rX rY r� r� r� rP rP rQ rL � s zCFloat.validateN).....).....).....r� rP rP rP rQ r � s. � � � r c @ sJ e Zd ZdZdZdZdddd�dd�Zd dd �d d �Zd dd�dd�ZdS )r" z A trait for complex numbers.y za complex numberrR �complex | Noner� c C s4 t |t�r|S t |ttf�r$t|�S | �||� d S rW )ra �complexrI rH r r� rP rP rQ rL s zComplex.validater\ rT c C s | j r|dkrd S t|�S r� )r� r� r� rP rP rQ r� s zComplex.from_stringr� rm r� c C s d S rW rP r� rP rP rQ r� s zComplex.subclass_initN� rM rN rO r� r� r� rL r� r� rP rP rP rQ r" � s r" c @ s" e Zd ZdZdddd�dd�ZdS )r z.A casting version of the complex number trait.rR r� r� c C s. z t |�W S ty( | �||� Y n0 d S rW )r� r� r r� rP rP rQ rL s zCComplex.validateN�rM rN rO r� rL rP rP rP rQ r s r c @ sJ e Zd ZdZdZdZdddd�dd�Zd dd �d d �Zd dd�dd�ZdS )r zA trait for byte strings.r� za bytes objectrR � bytes | Noner� c C s t |t�r|S | �||� d S rW )ra �bytesr r� rP rP rQ rL ( s zBytes.validater\ rT c C s� | j r|dkrd S t|�dkrzdD ]V}|d d� d|� �kr"|d |kr"|}|dd� }td|�d|�d �tdd � qzq"|�d �S ) Nrm r+ ��"r� r� �br$ zISupporting extra quotes around Bytes is deprecated in traitlets 5.0. Use � instead of r� r� �utf8)r� r� r r� �encode)rq rU �quote�old_srP rP rQ r� - s$ " ���zBytes.from_stringr� rm r� c C s d S rW rP r� rP rP rQ r� ? s zBytes.subclass_initNr� rP rP rP rQ r " s r c @ s" e Zd ZdZdddd�dd�ZdS )r z+A casting version of the byte string trait.rR r� r� c C s. z t |�W S ty( | �||� Y n0 d S rW )r� r� r r� rP rP rQ rL F s zCBytes.validateNr� rP rP rP rQ r C s r c @ s� e Zd ZdZdZdZejr�ejd"ddddd d d d d �d d��Z ejd#ddddd d d d d �dd��Z d$ddddd d d d d �dd�Z d d dd�dd�Z ddd�dd �Z d d d �d d �Z d!S )%r@ z A trait for unicode strings.r� za unicode string.zUnicode[str, str | bytes]r� r� r� r� rR rm r� c K s d S rW rP r� rP rP rQ rr U s zUnicode.__init__z'Unicode[str | None, str | bytes | None]�str | Sentinel | Noner� c K s d S rW rP r� rP rP rQ rr a s rS c K s d S rW rP r� rP rP rQ rr m s r� r� c C s� t |t�rt�t|�S t |t�rzzt�t|�dd��W S tyx } z*d}t|� || j t |���|�W Y d }~n d }~0 0 | � ||� d S )N�ascii�strictz<Could not decode {!r} for unicode trait '{}' of {} instance.) ra r\ rX rY r� r� �decode�UnicodeDecodeErrorr< r r� r r )rq r� rn r� r rP rP rQ rL x s 0zUnicode.validater\ rT c C s� | j r|dkrt�td �S tj�|�}t|�dkr�dD ]P}|d |d krV|kr6n q6|}|dd� }td|�d|�d �t dd � q6t�t|�S ) Nrm r� r� r r$ r zSSupporting extra quotes around strings is deprecated in traitlets 5.0. You can use r� z if you require traitlets >=5.r� ) r� rX rY r� �os�path� expanduserr� r r� )rq rU rL r� rP rP rQ r� � s$ ���zUnicode.from_stringr� r� c C s d S rW rP r� rP rP rQ r� � s zUnicode.subclass_initN).....).....).....) rM rN rO r� r� r� rX r� r rr rL r� r� rP rP rP rQ r@ M s6 � � � r@ c @ s� e Zd ZdZejrxejddddddddd d �d d ��Zejdd ddddddd d �dd ��Zdd ddddddd d �dd �Zdddd�dd�ZdS )r z'A casting version of the unicode trait..zCUnicode[str, t.Any]r� r� r� r� rR rm r� c K s d S rW rP r� rP rP rQ rr � s zCUnicode.__init__zCUnicode[str | None, t.Any]r� r� c K s d S rW rP r� rP rP rQ rr � s rS c K s d S rW rP r� rP rP rQ rr � s r� r� c C s6 zt �tt|��W S ty0 | �||� Y n0 d S rW )rX rY r� r\ r� r r� rP rP rQ rL � s zCUnicode.validateN).....).....).....r� rP rP rP rQ r � s. � � � r c @ sB e Zd ZdZdZedd� �Zdddd�dd �Zdd d �d d �ZdS )r7 z{A string holding a valid object name in this version of Python. This does not check that the name exists in any scope.z#a valid object identifier in Pythonc C s |S rW rP )r< rU rP rP rQ r� � r� zObjectName.<lambda>rR r\ r� c C s2 | � ||�}t|t�r"t|�r"|S | �||� d S rW )� coerce_strra r\ rZ r r� rP rP rQ rL � s zObjectName.validater� rT c C s | j r|dkrd S |S r� r� r� rP rP rQ r� � s zObjectName.from_stringN) rM rN rO r� r� � staticmethodr� rL r� rP rP rP rQ r7 � s r7 c @ s" e Zd ZdZdddd�dd�ZdS )r& zFA string holding a valid dotted object name in Python, such as A.b3._crR r\ r� c C sB | � ||�}t|t�r2tdd� |�d�D ��r2|S | �||� d S )Nc s s | ]}t |�V qd S rW )rZ )r r rP rP rQ r � r� z,DottedObjectName.validate.<locals>.<genexpr>r� )r� ra r\ �allr� r r� rP rP rQ rL � s "zDottedObjectName.validateNr� rP rP rP rQ r& � s r& c @ s� e Zd ZdZdZdZejr�ejd&ddddd d d d d �d d��Z ejd'ddddd d d d d �dd��Z d(ddddd d d d d �dd�Z d d dd�dd�Z ddd�dd �Z d d d �d d �Z d d!d"�d#d$�Z d%S ))r z A boolean (True, False) trait.Fz a boolean.zBool[bool, bool | int]�bool | Sentinelr� r� r� rR rm r� c K s d S rW rP r� rP rP rQ rr � s z Bool.__init__z$Bool[bool | None, bool | int | None]�bool | Sentinel | Noner� c K s d S rW rP r� rP rP rQ rr � s rS c K s d S rW rP r� rP rP rQ rr s r� r� c C sX t |t�rt�t|�S t |t�rH|dkr4t�td�S |dkrHt�td�S | �||� d S )Nr Tr F)ra rS rX rY r� rH r r� rP rP rQ rL s z Bool.validater\ rT c C sV | j r|dkrt�td �S |�� }|dv r6t�td�S |dv rJt�td�S td��d S )Nrm > �1�trueT> �false�0Fz %r is not 1, 0, true, or false)r� rX rY r� �lowerr_ r� rP rP rQ r� s zBool.from_stringr� r� c C s d S rW rP r� rP rP rQ r� ) s zBool.subclass_initr� r� c K s g d�}| j r|�d� |S )� Completion hints for argcomplete)r� r� r� r� rm )r� r~ )rq r� Z completionsrP rP rQ � argcompleter, s zBool.argcompleterN).....).....).....)rM rN rO r� r� r� rX r� r rr rL r� r� r� rP rP rP rQ r � s8 � � � r c @ s� e Zd ZdZejrxejddddddddd d �d d ��Zejdd ddddddd d �dd ��Zdd ddddddd d �dd �Zdddd�dd�ZdS )r z'A casting version of the boolean trait..zCBool[bool, t.Any]r� r� r� r� rR rm r� c K s d S rW rP r� rP rP rQ rr 9 s zCBool.__init__zCBool[bool | None, t.Any]r� r� c K s d S rW rP r� rP rP rQ rr E s rS c K s d S rW rP r� rP rP rQ rr Q s r� r� c C s6 zt �tt|��W S ty0 | �||� Y n0 d S rW )rX rY r� rS r� r r� rP rP rQ rL \ s zCBool.validateN).....).....).....r� rP rP rP rQ r 4 s. � � � r c s e Zd ZdZejr^ejd1ddddddd d d d � d d ��Zejd2ddddddd d d d � dd ��Zeddddfddddddd d d d � � fdd � Zd d dd�dd�Z d3ddd �d d �Z d4ddd �d d �Z dd!�d"d#�Z dd!�d$d%�Z ddd&�d'd(�Zd)d d*�d+d,�Zd d-d.�d/d0�Z� ZS )5r' z0An enum whose value must be in a given sequence..zEnum[G]z t.Sequence[G]z G | Sentinelr� r� r� rR rm ) rq r� r� r� r� r� r� r� rV c K s d S rW rP �rq r� r� r� r� r� r� r� rP rP rQ rr h s z Enum.__init__zEnum[G | None]zt.Sequence[G] | NonezG | Sentinel | Noner� c K s d S rW rP r� rP rP rQ rr u s FNrS c sR || _ |du r|tu rd }||d< ||d< ||d< ||d< t� j|fi |�� d S )NTr� r� r� r� )r� rA r5 rr r� r9 rP rQ rr � s r� r� c C s, | j r || j v r t�t|�S | �||� d S rW )r� rX rY r� r r� rP rP rQ rL � s z Enum.validater\ ��as_rstrV c C s4 | j pg }|r$d�dd� |D ��}n tt|��}|S )�6Returns a description of the trait choices (not none).�|c s s | ]}d | V qdS �z``%r``NrP �r r� rP rP rQ r � r� z$Enum._choices_str.<locals>.<genexpr>)r� r r r� )rq r� �choicesZ choice_strrP rP rQ � _choices_str� s zEnum._choices_strc C s. | j rd|rdnd nd}d| �|�� |� �S �r� � or %s�`None`rm r� �any of �r� r �rq r� �nonerP rP rQ �_info� s z Enum._inforu c C s | j dd�S �NF�r� �r rv rP rP rQ r � s z Enum.infoc C s | j dd�S �NTr r rv rP rP rQ �info_rst� s z Enum.info_rstrT c C s6 z| � d |�W S ty0 t�tt|�� Y S 0 d S rW )rL r< rX rY r� r` r� rP rP rQ r� � s zEnum.from_stringr� r� c C s d S rW rP r� rP rP rQ r� � s zEnum.subclass_initr� r� c K s dd� | j pg D �S )r� c S s g | ] }t |��qS rP )r\ )r r8 rP rP rQ rm � r� z%Enum.argcompleter.<locals>.<listcomp>)r� r� rP rP rQ r� � s zEnum.argcompleter).....).....)F)F)rM rN rO r� rX r� r rr rA rL r r r r r� r� r� r= rP rP r9 rQ r' c s< �" �"�$ r' c sr e Zd ZdZefdddddd�� fdd� Zdddd �d d �Zdd dd�dd�Zdd�dd�Zdd�dd�Z � Z S )r z4An enum of strings where the case should be ignored.zCaselessStrEnum[t.Any]rR rm )rq r� r� r� rV c s t � j|fd|i|�� d S �Nr� r� )rq r� r� r� r9 rP rQ rr � s zCaselessStrEnum.__init__r� r� c C sd t |t�s| �||� | jp g D ]2}t |t�s2J �|�� |�� kr t�t|� S q | �||� d S rW )ra r\ r r� r� rX rY r� )rq r� rn r8 rP rP rQ rL � s zCaselessStrEnum.validateFrS r\ r� c C s0 | j rd|rdnd nd}d| �|�� d|� �S )r� r r rm r� r z (case-insensitive)r r rP rP rQ r � s zCaselessStrEnum._inforu c C s | j dd�S r r rv rP rP rQ r � s zCaselessStrEnum.infoc C s | j dd�S r r rv rP rP rQ r � s zCaselessStrEnum.info_rst)F) rM rN rO r� rA rr rL r r r r= rP rP r9 rQ r � s � r c s� e Zd ZdZdZdZeddfdddddddd�� fdd � Zddd d �d d �Zdddd�dd�Z dd�dd�Z dd�dd�Z � Z S )r- zEAn case-ignoring enum matching choices by unique prefixes/substrings.FzFuzzyEnum[t.Any]rR rS rm )rq r� r� �case_sensitive�substring_matchingr� rV c s( || _ || _t� j|fd|i|�� d S r )r r r5 rr )rq r� r� r r r� r9 rP rQ rr � s zFuzzyEnum.__init__r� r� c s� t �t�s| �|�� | jr$dd� ndd� � | j}|r>dd� ndd� �� ���| jpVg }� ��fdd�|D �}t|�dkr�t||�D ]\}}|r�| S q�| �|�� d S ) Nc S s | S rW rP �rL rP rP rQ r� � r� z$FuzzyEnum.validate.<locals>.<lambda>c S s | � � S rW )r� r rP rP rQ r� � r� c S s | |v S rW rP �r8 rL rP rP rQ r� � r� c S s |� | �S rW )� startswithr rP rP rQ r� � r� c s g | ]}��� |���qS rP rP )r rL �Z conv_func� match_funcrn rP rQ rm � r� z&FuzzyEnum.validate.<locals>.<listcomp>r )ra r\ r r r r� �sum�zip)rq r� rn r r �matchesr8 �mrP r rQ rL � s zFuzzyEnum.validater\ r� c C sV | j rd|rdnd nd}| jr$dnd}| jr2dnd}d |� d |� d | �|�� |� �S ) r� r r rm r� Z sensitiveZ insensitiveZ substring�prefixz any case-� r )r� r r r )rq r� r �case�substrrP rP rQ r s zFuzzyEnum._inforu c C s | j dd�S r r rv rP rP rQ r s zFuzzyEnum.infoc C s | j dd�S r r rv rP rP rQ r s zFuzzyEnum.info_rst)F) rM rN rO r� r r rA rr rL r r r r= rP rP r9 rQ r- � s � r- c sz e Zd ZU dZdZded< dZded< eZdZ ded< d Z ded < e j d d d d �d ddddddd�dd��Z e j d d d d �dddddddd�dd��Z e j d d d d d d�d dddddddd �d d��Z dedddfdddddddd �� fd d� Z ddd d!�� fd"d#� Zddd d!�d$d%�Zd&ddd'�� fd(d)� Zd&dd*�d+d,�Zdd d-�d.d/�Zd0d d1�d2d3�Zd9dd4d5d6�d7d8�Z� ZS ):r# z\An instance of a container (list, set, etc.) To be subclassed by overriding klass. Nztype[T] | Noner� rP rR � _cast_types�_trait)�[]�()�_literal_from_string_pairs.r� z Container[T]r� r� r� r� rm )rq r� r� r� r� r� rV c K s d S rW rP �rq r� r� r� r� r� rP rP rQ rr s zContainer.__init__zContainer[T | None]r� c K s d S rW rP r( rP rP rQ rr ' s )r� r� r� r� r� r\ rS )rq r� r� r� r� r� r� rV c K s d S rW rP )rq r� r� r� r� r� r� rP rP rQ rr 3 s )r� r� r� r� r� r� rV c s |dur |t u r t|�s |}d}|du rR|�dd�sRtd| jj� d�tdd� t }|t u r`d}nB|du rvd}d|d < n,t|| j�r�|f}nt d | jj� d |� ���t|�r�t|t �r�td td d� t|t �r�|� n|| _ n|dur�t dt |� ��t � jf | j||||d�|�� dS )a� 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 **kwargs : any further keys for extensions to the Trait (e.g. config) Nr� F� Specifying �a(default_value=None) for no default is deprecated in traitlets 5.0.5. Use default_value=Undefinedr� r� rP r� �default value of � was r2 r+ z'`trait` must be a Trait or None, got %s)r� r r� r� r� )rA rd r� r r rM r� ra �_valid_defaultsrj rb r$ r r5 rr r� )rq r� r� r� r� r� r� r r9 rP rQ rr @ sB &� � ��r� r� c sV t || j�r$| jd usJ �| �|�}t� �||�}|d u r>|S | �||�}t�t|�S rW ) ra r# r� r5 rL �validate_elementsrX rY r� r� r9 rP rQ rL � s zContainer.validatec C s� g }| j d u st| j t�r&t�t|�S |D ]T}z| j �||�}W n2 tyr } z| �|||� W Y d }~q*d }~0 0 |� |� q*| j d us�J �| � |�S rW ) r$ ra r rX rY r� r� r< r r~ r� )rq r� rn � validatedr8 r rP rP rQ r. � s $ zContainer.validate_elementsr� r� c s, t | jt�r| j�|d � t� �||� d S rW )ra r$ r= r� r5 r� r9 rP rQ r� � s zContainer.class_initr� c C s t | jt�r| j�|� d S rW )ra r$ r= r� r� rP rP rQ r� � s zContainer.subclass_initrT c C sH t |t�std|����z t|�}W n ty: d}Y n0 | �d|�S )� Load value from a single stringzExpected string, got N)ra r\ r< r r� rL �rq rU rs rP rP rQ r� � s zContainer.from_stringr� ��s_listrV c s� �j dusJ �t|�dkr�|d ��dkr4�jr4dS t��dkr�t�fdd��jD ��r��jrl�jjd }nd }�jdus~J �td � |�j ��t dd � �� t ���S t � �j�}d |jv rƈj� ndd ddd��fdd� � �� � fdd�t|�D ��S )ziReturn the value from a list of config strings This is where we parse CLI configuration Nr r rm r� c 3 s& | ] \}}� � |�o � �|�V qd S rW )r �endswith)r �start�end)�rrP rQ r � s �z-Container.from_string_list.<locals>.<genexpr>r� r� z}--{0}={1} for containers is deprecated in traitlets 5.0. You can pass `--{0} item` ... multiple times to add items to a list.r� rD r\ � int | None�T | str�rU rD rV c s t �t� �| ��S rW )rX rY r� �item_from_string)rU rD rv rP rQ r; � s z4Container.from_string_list.<locals>.item_from_stringc s g | ]\}}� ||d ��qS ))rD rP )r �idxrU �r; rP rQ rm � r� z.Container.from_string_list.<locals>.<listcomp>)N)r� r� r� �anyr' r� rM r� r r r� r r� � signaturer; � parameters� enumerate)rq r3 rU �sigrP )r; r7 rq rQ �from_string_list� s6 � �� �zContainer.from_string_listr8 r9 r: c C s" | j rt�t| j �|��S |S dS )�iCast a single item from a string Evaluated when parsing CLI configuration from a string N)r$ rX rY r� r� �rq rU rD rP rP rQ r; � s zContainer.item_from_string)N)rM rN rO r� r� r� r# � SequenceTypesr- r$ r' rX r rr rA rL r. r� r� r� rC r; r= rP rP r9 rQ r# sH � � �"� R )r# c s� e Zd ZU dZeZefZded< de de j fdddddd d �� fd d � Z ddd d �dd�Z dddd �� fdd� Zddd d �� fdd� Z� ZS )r3 z An instance of a Python list.rR r# Nr zIt.List[T] | t.Tuple[T] | t.Set[T] | Sentinel | TraitType[T, t.Any] | Nonez3t.List[T] | t.Tuple[T] | t.Set[T] | Sentinel | NonerH rm �r� r� �minlen�maxlenr� rV c s( || _ || _t� jf ||d�|�� dS )a� 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� r� N��_maxlen�_minlenr5 rr �rq r� r� rH rI r� r9 rP rQ rr � s "z List.__init__r� c C s( d| j t|�| j| j|f }t|��d S �Nz_The '%s' trait of %s instance must be of length %i <= L <= %i, but a value of %s was specified.�r� r rM rL r< r� rP rP rQ � length_error! s ��zList.length_errorc s6 t |�}|| jk s || jkr(| �||� t� �||�S rW �r� rM rL rQ r5 r. �rq r� rn �lengthr9 rP rQ r. ( s zList.validate_elementsc s, t |t�rt� �||g�S t� �||�S d S rW �ra r\ r5 r� r� r9 rP rQ r� / s zList.set)rM rN rO r� r� r� r� r# r� rA �sys�maxsizerr rQ r. r� r= rP rP r9 rQ r3 � s � &r3 c s� e Zd ZdZeZeefZdZ de de j fddddddd�� fd d � Z dddd �d d �Zdddd �� fdd� Zdddd �� fdd� Zdd�dd�Z� ZS )r9 z An instance of a Python set.)r% r& z{}Nr rR rH rm rG c s( || _ || _t� jf ||d�|�� dS )a� 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 rJ NrK rN r9 rP rQ rr ? s "z Set.__init__r� c C s( d| j t|�| j| j|f }t|��d S rO rP r� rP rP rQ rQ e s ��zSet.length_errorc s6 t |�}|| jk s || jkr(| �||� t� �||�S rW rR rS r9 rP rQ r. l s zSet.validate_elementsc s, t |t�rt� �||h�S t� �||�S d S rW rU r� r9 rP rQ r� s s zSet.setr\ ru c C s4 t t| �� pg ��}|dkr dS d|dd� d S )Nr% zset()�{r r$ �})r r� r� )rq Z list_reprrP rP rQ r y s zSet.default_value_repr)rM rN rO r� r� r� r� r� r# r' rA rV rW rr rQ r. r r= rP rP r9 rQ r9 6 s � &r9 c s~ e Zd ZdZeZefZdddd�� fdd� Zdddd �d d �Z dddd �d d�Z dddd�� fdd� Z ddd�dd�Z � Z S )r> z An instance of a Python tuple.rR rm )r� r� rV c s6 |� dt�}t|�dkr8|tu r8t|d �s8|d }d}|du rj|�dd�sjtd| jj� d �td d � t}|tu rxd}nB|du r�d}d|d< n,t || j �r�|f}nt d | jj� d |� ���g | _ |D ].}t |t �r�tdtd d � |� }| j �|� q�| j �r|du �s|tu �rd}tt| �jf | j|d�|�� dS )aG 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, ``default_value`` must conform to the shape and type they specify. **kwargs Other kwargs passed to `Container` r� r r rP Nr� Fr) r* r� r� r+ r, �~Traits should be given as instances, not types (for example, `Int()`, not `Int`) Passing types is deprecated in traitlets 4.1.�r� r )r� rA r� rd r� r r rM r� ra r- rj rA rb r~ r5 r# rr r� )rq r� r� r� r r� r9 rP rQ rr � s@ � � zTuple.__init__r\ rH r: c C s( | j r|t| j �kr|S | j | �|�S )rD )rA r� r� rE rP rP rQ r; � s zTuple.item_from_stringr� c C s� | j s |S t|�t| j �krDd| jt|�t| j �t|�f }t|��g }t| j |�D ]V\}}z|�||�}W n2 ty� } z| �|||� W Y d }~qTd }~0 0 |� |� qTt |�S )NzTThe '%s' trait of %s instance requires %i elements, but a value of %s was specified.) rA r� r� r r r< r r� r r~ r� )rq r� rn r� r/ r� r8 r rP rP rQ r. � s ��$ zTuple.validate_elementsr� r� r� c s8 | j D ]}t|t�r|�|d � qtt| ��||� d S rW )rA ra r= r� r5 r# �rq r� r� r� r9 rP rQ r� � s zTuple.class_initr� c C s$ | j D ]}t|t�r|�|� qd S rW )rA ra r= r� �rq r� r� rP rP rQ r� � s zTuple.subclass_init)rM rN rO r� r� r� r� r# rr r; r. r� r� r= rP rP r9 rQ r> � s M r> c s� e Zd ZdZdZdZdddefddddddd�� fd d � Zd)dddd dd �dd�Zdddd�� fdd� Z dddd�dd�Z dddd�� fdd� Z ddd �d d �Z d dd �d d!�Z d"dd#�d$d%�Zd d&d �d'd(�Z� ZS )*r% a� An instance of a Python dict. One or more traits can be passed to the constructor to validate the keys and/or values of the dict. If you need more detailed validation, you may use a custom validator method. .. versionchanged:: 5.0 Added key_trait for validating dict keys. .. versionchanged:: 5.0 Deprecated ambiguous ``trait``, ``traits`` args in favor of ``value_trait``, ``per_key_traits``. Nz6TraitType[t.Any, t.Any] | dict[K, V] | Sentinel | NonerR z TraitType[t.Any, t.Any] | Nonez dict[K, V] | Sentinel | Nonerm )� value_trait�per_key_traits� key_traitr� r� rV c s� |� dd�}|dur6|dur$td��|}tdtdd� |� dd�}|durl|durZtd��|}td tdd� |tu r�|dur�t|�s�t|t�r�J �|}d}|du r�|dur�t|�r�|}d}|tu r�i }|du r�d}n0t|t�r�|f}n t|t �r�|f}n td | ��t|��r6t|t ��r.td tdd� |� }|| _ n|du�rPtd t |� ��t|��r�t|t ��rztd tdd� |� }|| _ n|du�r�td t |� ��|| _t� jf t|d�|�� dS )a Create a dict trait type from a Python dict. The default value is created by doing ``dict(default_value)``, which creates a copy of the ``default_value``. Parameters ---------- value_trait : TraitType [ optional ] The specified trait type to check and use to restrict the values of the dict. If unspecified, values are not checked. per_key_traits : Dictionary of {keys:trait types} [ optional, keyword-only ] A Python dictionary containing the types that are valid for restricting the values of the dict on a per-key basis. Each value in this dict should be a Trait for validating key_trait : TraitType [ optional, keyword-only ] The type for restricting the keys of the dict. If unspecified, the types of the keys are not checked. default_value : SequenceType [ optional, keyword-only ] The default value for the Dict. Must be dict, tuple, or None, and will be cast to a dict if not None. If any key or value traits are specified, the `default_value` must conform to the constraints. Examples -------- a dict whose values must be text >>> d = Dict(Unicode()) d2['n'] must be an integer d2['s'] must be text >>> d2 = Dict(per_key_traits={"n": Integer(), "s": Unicode()}) d3's keys must be text d3's values must be integers >>> d3 = Dict(value_trait=Integer(), key_trait=Unicode()) r� NzFFound a value for both `value_trait` and its deprecated alias `trait`.zIKeyword `trait` is deprecated in traitlets 5.0, use `value_trait` insteadr� r� r� zJFound a value for both `per_key_traits` and its deprecated alias `traits`.zMKeyword `traits` is deprecated in traitlets 5.0, use `per_key_traits` insteadz default value of Dict was %srZ z-`value_trait` must be a Trait or None, got %sz+`key_trait` must be a Trait or None, got %sr[ )r� rj r r� rA rd ra r= rT rF rb � _value_traitr � _key_trait�_per_key_traitsr5 rr ) rq r^ r_ r` r� r� r� r� r r9 rP rQ rr s� . �� �� � � � z Dict.__init__�Valuesr\ )r� �element� validator�siderV c C s< |d| j � dt|�� d|�� � dt|�� d� }t|��d S )Nz of the 'r� z instance must be r� z was specified.)r� r r r r< )rq r� re rf rg r� rP rP rQ � element_error� s *��zDict.element_errorzdict[K, V] | Noner� c s& t � �||�}|d u r|S | �||�S rW )r5 rL r. r� r9 rP rQ rL � s z Dict.validatezdict[t.Any, t.Any]c C s� | j pi }| j}| j}|s&|s&|s&|S i }|D ]�}|| }|rrz|�||�}W n" typ | �|||d� Y n0 |�||�} | r�z| �||�}W n" ty� | �||| d� Y n0 |||< q.| �|�S )NZKeysrd )rc rb ra r� r< rh r� r� ) rq r� rn Zper_key_overrider` r^ r/ r� r8 Zactive_value_traitrP rP rQ r. � s* zDict.validate_elementsr� r� r� c sl t | jt�r| j�|d � t | jt�r4| j�|d � | jd urZ| j�� D ]}|�|d � qHt� �||� d S rW )ra ra r= r� rb rc r� r5 r\ r9 rP rQ r� � s zDict.class_initr� c C sX t | jt�r| j�|� t | jt�r0| j�|� | jd urT| j�� D ]}|�|� qDd S rW )ra ra r= r� rb rc r� r] rP rP rQ r� � s zDict.subclass_initrT c C sl t |t�s"td|�dt|�� ���zt�d| �|g��W S tyf t|�}t |t �r`| Y S � Y n0 dS )r0 z"from_string expects a string, got z of type � dict[K, V]N) ra r\ rj rb rX rY rC r� r` rT r1 rP rP rQ r� � s zDict.from_stringr� r2 c s� t |�dkr"|d dkr"� jr"dS t |�dkr�|d �d�r�|d �d�r�td� j� d|d � d � j� d �td d � t|d �S i }� fd d�|D �D ]}|�|� q�|S )z�Return a dict from a list of config strings. This is where we parse CLI configuration. Each item should have the form ``"key=value"``. item parsing is done in :meth:`.item_from_string`. r r rm NrX rY z--rn z@ for dict-traits is deprecated in traitlets 5.0. You can pass --z7 <key=value> ... multiple times to add items to a dict.r� r� c s g | ]}� � |��qS rP r= )r rU rv rP rQ rm � r� z)Dict.from_string_list.<locals>.<listcomp>) r� r� r r4 r r� r� r r� )rq r3 �combinedrv rP rv rQ rC � s (�� zDict.from_string_listri c C st d|vr t d| jj� d|����|�dd�\}}| jrB| j�|�}| jpJi �|| j�}|rd|�|�}t � d||i�S )a Cast a single-key dict from a string. Evaluated when parsing CLI configuration from a string. Dicts expect strings of the form key=value. Returns a one-key dictionary, which will be merged in :meth:`.from_string_list`. rn r� z.' options must have the form 'key=value', got r ri ) r< r rM r� rb r� rc r� ra rX rY )rq rU r� rn r^ rP rP rQ r; � s � zDict.item_from_string)rd )rM rN rO r� ra rb rA rr rh rL r. r� r� r� rC r; r= rP rP r9 rQ r% s$ � � r% ri c @ s� e Zd ZdZdZdZejr�ejd ddddd d d d d �d d��Z ejd!ddddd d d d d �dd��Z e ddddfddddd d d d d �dd�Z d d dd�dd�Z d dd �d d �Z dS )"r: zgA trait for an (ip, port) tuple. This allows for both IPv4 IP addresses as well as hostnames. )z 127.0.0.1r zan (ip, port) tuple.z,TCPAddress[tuple[str, int], tuple[str, int]]r� r� r� r� rR rm r� c K s d S rW rP r� rP rP rQ rr s zTCPAddress.__init__z:TCPAddress[tuple[str, int] | None, tuple[str, int] | None]zbool | None | Sentinelr� c K s d S rW rP r� rP rP rQ rr * s FNziTCPAddress[tuple[str, int] | None, tuple[str, int] | None] | TCPAddress[tuple[str, int], tuple[str, int]]r� c K s d S rW rP r� rP rP rQ rr 6 s r� r� c C sf t |t�rVt|�dkrVt |d t�rVt |d t�rV|d }|dkrV|dkrVt�t|�S | �||� d S )Nr� r r i�� ) ra r� r� r\ rH rX rY r� r )rq r� rn �portrP rP rQ rL B s zTCPAddress.validater\ rT c C sV | j r|dkrt�td �S d|vr.td| ��|�dd�\}}t|�}t�t||f�S )Nrm �:zRequire `ip:port`, got %rr )r� rX rY r� r_ r� rH )rq rU �ipZport_strrk rP rP rQ r� K s zTCPAddress.from_string).....).....) rM rN rO r� r� r� rX r� r rr rA rL r� rP rP rP rQ r: s4 � � � r: c @ s& e Zd ZdZdZdddd�dd�ZdS ) r z�A casting compiled regular expression trait. Accepts both strings and compiled regular expressions. The resulting attribute will be a compiled regular expression.za regular expressionrR zre.Pattern[t.Any] | Noner� c C s0 z t �|�W S ty* | �||� Y n0 d S rW )�re�compiler� r r� rP rP rQ rL ] s zCRegExp.validateN�rM rN rO r� r� rL rP rP rP rQ r U s r zre.Pattern[t.Any]c s� e Zd ZU dZdZded< dZd"ddddd �� fd d � Zefd ddd �dd�Z efdddd �dd�Z dddd�dd�Z d#ddd�dd�Z d$ddd�dd �Z dd �d d �Zdd �d d!�Z� ZS )%rC as Use a Enum class as model for the data type description. Note that if no default-value is provided, the first enum-value is used as default-value. .. sourcecode:: python # -- SINCE: Python 3.4 (or install backport: pip install enum34) import enum from traitlets import HasTraits, UseEnum class Color(enum.Enum): red = 1 # -- IMPLICIT: default_value blue = 2 green = 3 class MyEntity(HasTraits): color = UseEnum(Color, default_value=Color.blue) entity = MyEntity(color=Color.red) entity.color = Color.green # USE: Enum-value (preferred) entity.color = "green" # USE: name (as string) entity.color = "Color.green" # USE: scoped-name (as string) entity.color = 3 # USE: number (as int) assert entity.color is Color.green Nzenum.Enum | Noner� z"Trait type adapter to a Enum classr� rR rm )� enum_classr� r� rV c sn t |tj�sJ d| ��|�dd�}|d u rB|sBtt|j�� ��}t� j f d|i|�� || _ |j d | _ d S )Nz REQUIRE: enum.Enum, but was: %rr� Fr� r� ) rc �enumr' r� �next�iter� __members__r� r5 rr rq rM � name_prefix)rq rq r� r� r� r9 rP rQ rr � s zUseEnum.__init__rH )rn rE rV c C s: t |t�sJ �| jj}|�� D ]}|j|kr | S q |S )z0Selects enum-value by using its number-constant.)ra rH rq ru r� rn )rq rn rE � enum_membersZ enum_itemrP rP rQ �select_by_number� s zUseEnum.select_by_numberr\ c C s: t |t�sJ �|�| j�r*|�| jdd�}| jj�||�S )z4Selects enum-value by using its name or scoped-name.r� r )ra r\ r rv �replacerq ru r� )rq rn rE rP rP rQ �select_by_name� s zUseEnum.select_by_namer� c C s| t || j�r|S t |t�r2| �|�}|turl|S n:t |t�rT| �|�}|turl|S n|d u rl| jrfd S | jS | � ||� d S rW ) ra rq rH rx rA r\ rz r� r� r )rq r� rn Zvalue2rP rP rQ rL � s zUseEnum.validateFrS r� c C s4 | j j�� }|r$d�dd� |D ��S tt|��S dS )r r c s s | ]}d | V qdS r rP r rP rP rQ r � r� z'UseEnum._choices_str.<locals>.<genexpr>N)rq ru r r r r� )rq r� r rP rP rQ r � s zUseEnum._choices_strc C s. | j rd|rdnd nd}d| �|�� |� �S r r r rP rP rQ r � s z UseEnum._inforu c C s | j dd�S r r rv rP rP rQ r � s z UseEnum.infoc C s | j dd�S r r rv rP rP rQ r � s zUseEnum.info_rst)N)F)F)rM rN rO r� r� r� r� rr rA rx rz rL r r r r r= rP rP r9 rQ rC d s � rC c @ s& e Zd ZdZdZdddd�dd�ZdS )r zxA trait which is callable. Notes ----- Classes are callable, as are instances with a __call__() method.z a callablerR r� c C s t |�r |S | �||� d S rW )r� r r� rP rP rQ rL � s zCallable.validateNrp rP rP rP rQ r � s r )N)r� � __future__r r� rr r� r� rn rV r& �typingrX �astr Z utils.bunchr Zutils.descriptionsr r r r Zutils.getargspecr Zutils.importstringr Zutils.sentinelr Zutils.warningsr r r r� r� r� � frozensetrF rb Z ClassTypesr� �typing_extensionsr �__all__rA r ZNoDefaultSpecifiedr� r< rZ r` rd rK rl r� r� rH rF rG r r� r� r� r� r� r\ r� r r� �Genericr= r! r- r5 r6 rI rJ rL rE r rP r( r8 rD r$ r. r/ r! r? r0 r+ r, r* �Optionalr; rB r� r1 r r4 r r2 r) r r� rI rH r" r r� r r r@ r r7 r& r r r' r r- r# r3 r9 r> r% r: r rC rP rP rP rQ �<module> s� ) E�� OC: $9Y &!) % 8 ' !$ Y(K@0 B0$ ! L$/ K/Y!2 gA K B" f
| ver. 1.1 | |
.
| PHP 8.3.30 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0 |
proxy
|
phpinfo
|
ÐаÑтройка