3
“ž_Fƒ  ã               @   s>  d dl Z d dlmZmZ d dlmZ d dlmZ yd dl	m
Z
 W n  ek
r`   d dlm
Z
 Y nX dddd	d
ddgZdd„ Zdd„ Zdd„ Zdd„ Zeƒ ZG dd„ dƒZG dd„ deƒZdZG dd„ deƒZG dd„ ded�ZG dd„ deeƒZdd„ ZG dd	„ d	eƒZG dd
„ d
eeƒZd d!„ Zd"d„ Z d#d$„ Z!d%d&„ Z"dS )'é    N)ÚMappingProxyTypeÚDynamicClassAttribute)Úreduce)Úor_)ÚOrderedDictÚEnumMetaÚEnumÚIntEnumÚFlagÚIntFlagÚautoÚuniquec             C   s   t | dƒpt | dƒpt | dƒS )z5Returns True if obj is a descriptor, False otherwise.Ú__get__Ú__set__Ú
__delete__)Úhasattr)Úobj© r   ú9/home/yuhw/wc/wire-cell-python/venv/lib/python3.6/enum.pyÚ_is_descriptor   s    

r   c             C   sT   | dd… | dd…   ko"dkn  oR| dd… dkoR| dd	… dkoRt | ƒdkS )
z3Returns True if a __dunder__ name, False otherwise.Né   Z__é   Ú_é   éþÿÿÿéýÿÿÿr   )Úlen)Únamer   r   r   Ú
_is_dunder   s    (r   c             C   sL   | d | d   kodkn  oJ| dd… dkoJ| dd… dkoJt | ƒdkS )z1Returns True if a _sunder_ name, False otherwise.r   é   r   r   éÿÿÿÿr   r    )r   )r   r   r   r   Ú
_is_sunder$   s     r!   c             C   s   dd„ }|| _ d| _dS )z"Make the given class un-picklable.c             S   s   t d|  ƒ‚d S )Nz%r cannot be pickled)Ú	TypeError)ÚselfÚprotor   r   r   Ú_break_on_call_reduce-   s    z6_make_class_unpicklable.<locals>._break_on_call_reducez	<unknown>N)Ú__reduce_ex__Ú
__module__)Úclsr%   r   r   r   Ú_make_class_unpicklable+   s    r)   c               @   s   e Zd ZdZeZdS )r   zP
    Instances are replaced with an appropriate value in Enum class suites.
    N)Ú__name__r'   Ú__qualname__Ú__doc__Ú
_auto_nullÚvaluer   r   r   r   r   3   s   c                   s,   e Zd ZdZ‡ fdd„Z‡ fdd„Z‡  ZS )Ú	_EnumDictz§Track enum member order and ensure member names are not reused.

    EnumMeta will use the names found in self._member_names as the
    enumeration member names.

    c                s   t ƒ jƒ  g | _g | _d S )N)ÚsuperÚ__init__Ú_member_namesÚ_last_values)r#   )Ú	__class__r   r   r1   A   s    
z_EnumDict.__init__c                sæ   t |ƒr.|dkrtdƒ‚|dkrÔt| d|ƒ n¦t|ƒrD|dkrÔd}n�|| jkr\td| ƒ‚nxt|ƒsÔ|| kr€td	|| | f ƒ‚t|tƒr¼|j	t
kr¶| j|d
t| jƒ| jdd… ƒ|_	|j	}| jj|ƒ | jj|ƒ tƒ j||ƒ dS )zåChanges anything not dundered or not a descriptor.

        If an enum member name is used twice, an error is raised; duplicate
        values are not checked for.

        Single underscore (sunder) names are reserved.

        Ú_order_Ú_create_pseudo_member_Ú_generate_next_value_Ú	_missing_z(_names_ are reserved for future Enum useÚ_generate_next_valueZ	__order__zAttempted to reuse key: %rz%r already defined as: %rr   N)r5   r6   r7   r8   )r!   Ú
ValueErrorÚsetattrr   r2   r"   r   Ú
isinstancer   r.   r-   r9   r   r3   Úappendr0   Ú__setitem__)r#   Úkeyr.   )r4   r   r   r>   F   s,    	 


"z_EnumDict.__setitem__)r*   r'   r+   r,   r1   r>   Ú__classcell__r   r   )r4   r   r/   :   s   r/   c                   sÚ   e Zd ZdZedd„ ƒZ‡ fdd„Zdd„ Zd)dddd	d
œdd„Zdd„ Z	‡ fdd„Z
dd„ Zdd„ Zdd„ Zdd„ Zdd„ Zedd„ ƒZdd„ Zdd „ Z‡ fd!d"„Zdddd	d
œd#d$„Zed%d&„ ƒZed'd(„ ƒZ‡  ZS )*r   zMetaclass for Enumc             C   s0   t ƒ }| j|ƒ\}}|d k	r,t|dd ƒ|d< |S )Nr7   )r/   Ú_get_mixins_Úgetattr)Úmetaclsr(   ÚbasesZ	enum_dictÚmember_typeÚ
first_enumr   r   r   Ú__prepare__r   s
    zEnumMeta.__prepare__c                sì  | j |ƒ\‰}| jˆ ˆ|ƒ\}}}‡ fdd„ˆ jD ƒ}xˆ jD ]
}	ˆ |	= q>W ˆ jdd ƒ}
t|ƒdh@ }|r~tdjdj|ƒƒƒ‚dˆ krŽdˆ d< tƒ j	| ||ˆ ƒ}g |_
tƒ |_ˆ|_d	d
„ |jƒ D ƒ}i |_dˆ k�rˆtk	�rd}t‡fdd„|D ƒƒ�st|ƒ �x6ˆ jD �]*}|| }t|tƒ�s0|f}n|}ˆtk�rD|f}|�sf||ƒ}t|dƒ�sœ||_n6||f|žŽ }t|dƒ�sœˆtk�r’||_n
ˆ|Ž |_|j}||_||_|j|Ž  x8|jjƒ D ]\}	}|j|jk�rÄ|}P �qÄW |j
j|ƒ ||k�rt|||ƒ ||j|< y||j|< W n tk
�r6   Y nX �qW xPdD ]H}	t||	ƒ}tˆ|	d ƒ}t||	d ƒ}|d k	�rD||k�rDt||	|ƒ �qDW td k	�r®|�r¦||_ tj	|_	|
d k	�rèt|
t!ƒ�rÔ|
j"ddƒj#ƒ }
|
|j
k�rètdƒ‚|S )Nc                s   i | ]}ˆ | |“qS r   r   )Ú.0Úk)Ú	classdictr   r   ú
<dictcomp>‡   s    z$EnumMeta.__new__.<locals>.<dictcomp>r5   ÚmrozInvalid enum member name: {0}ú,r,   zAn enumeration.c             S   s.   h | ]&}|j jƒ D ]\}}t|tƒr|’qqS r   )Ú__dict__Úitemsr<   r   )rH   ÚcrI   Úvr   r   r   ú	<setcomp>    s    z#EnumMeta.__new__.<locals>.<setcomp>r&   Ú__getnewargs_ex__Ú__getnewargs__Ú
__reduce__c             3   s   | ]}|ˆ j kV  qd S )N)rN   )rH   Úm)rE   r   r   ú	<genexpr>µ   s    z#EnumMeta.__new__.<locals>.<genexpr>Ú_value_Ú__repr__Ú__str__Ú
__format__ú z#member order does not match _order_)rS   rT   r&   rU   )rY   rZ   r[   r&   )$rA   Ú
_find_new_r2   ÚpopÚsetr:   ÚformatÚjoinr0   Ú__new__Ú_member_names_r   Ú_member_map_Ú_member_type_rL   Ú_value2member_map_ÚobjectÚanyr)   r<   Útupler   rX   Ú_name_Ú__objclass__r1   rO   r=   r;   r"   rB   r   Ú__new_member__ÚstrÚreplaceÚsplit)rC   r(   rD   rJ   rF   rb   Úsave_newÚuse_argsZenum_membersr   r5   Zinvalid_namesÚ
enum_classZdynamic_attributesÚmethodsÚmember_namer.   ÚargsZenum_memberZcanonical_memberZclass_methodZ
obj_methodZenum_method)r4   )rJ   rE   r   rb   |   s’    


 









zEnumMeta.__new__c             C   s   dS )z6
        classes/types should always be True.
        Tr   )r#   r   r   r   Ú__bool__  s    zEnumMeta.__bool__Nr   )ÚmoduleÚqualnameÚtypeÚstartc            C   s*   |dkr| j | |ƒS | j||||||d�S )a  Either returns an existing member, or creates a new enum class.

        This method is used both when an enum class is given a value to match
        to an enumeration member (i.e. Color(3)) and for the functional API
        (i.e. Color = Enum('Color', names='RED GREEN BLUE')).

        When used for the functional API:

        `value` will be the name of the new class.

        `names` should be either a string of white-space/comma delimited names
        (values will start at `start`), or an iterator/mapping of name, value pairs.

        `module` should be set to the module this class is being created in;
        if it is not set, an attempt to find that module will be made, but if
        it fails the class will not be picklable.

        `qualname` should be set to the actual location this class can be found
        at in its module; by default it is set to the global scope.  If this is
        not correct, unpickling will fail in some circumstances.

        `type`, if set, will be mixed in as the first base class.

        N)rw   rx   ry   rz   )rb   Ú_create_)r(   r.   Únamesrw   rx   ry   rz   r   r   r   Ú__call__  s    zEnumMeta.__call__c             C   s   t || ƒo|j| jkS )N)r<   rj   rd   )r(   Úmemberr   r   r   Ú__contains__)  s    zEnumMeta.__contains__c                s(   || j krtd| j ƒ‚tƒ j|ƒ d S )Nz%s: cannot delete Enum member.)rd   ÚAttributeErrorr*   r0   Ú__delattr__)r(   Úattr)r4   r   r   r�   ,  s    
zEnumMeta.__delattr__c             C   s   ddddg| j  S )Nr4   r,   Ú__members__r'   )rc   )r#   r   r   r   Ú__dir__4  s    
zEnumMeta.__dir__c             C   s>   t |ƒrt|ƒ‚y
| j| S  tk
r8   t|ƒd‚Y nX dS )a5  Return the enum member matching `name`

        We use __getattr__ instead of descriptors or inserting into the enum
        class' __dict__ in order to support `name` and `value` being both
        properties for enum members (which live in the class' __dict__) and
        enum members themselves.

        N)r   r€   rd   ÚKeyError)r(   r   r   r   r   Ú__getattr__8  s    	
zEnumMeta.__getattr__c             C   s
   | j | S )N)rd   )r(   r   r   r   r   Ú__getitem__H  s    zEnumMeta.__getitem__c                s   ‡ fdd„ˆ j D ƒS )Nc             3   s   | ]}ˆ j | V  qd S )N)rd   )rH   r   )r(   r   r   rW   L  s    z$EnumMeta.__iter__.<locals>.<genexpr>)rc   )r(   r   )r(   r   Ú__iter__K  s    zEnumMeta.__iter__c             C   s
   t | jƒS )N)r   rc   )r(   r   r   r   Ú__len__N  s    zEnumMeta.__len__c             C   s
   t | jƒS )z·Returns a mapping of member name->value.

        This mapping lists all enum members, including aliases. Note that this
        is a read-only view of the internal mapping.

        )r   rd   )r(   r   r   r   rƒ   Q  s    zEnumMeta.__members__c             C   s
   d| j  S )Nz	<enum %r>)r*   )r(   r   r   r   rY   [  s    zEnumMeta.__repr__c                s   ‡ fdd„t ˆ jƒD ƒS )Nc             3   s   | ]}ˆ j | V  qd S )N)rd   )rH   r   )r(   r   r   rW   _  s    z(EnumMeta.__reversed__.<locals>.<genexpr>)Úreversedrc   )r(   r   )r(   r   Ú__reversed__^  s    zEnumMeta.__reversed__c                s0   | j jdi ƒ}||krtdƒ‚tƒ j||ƒ dS )zùBlock attempts to reassign Enum members.

        A simple assignment to the class namespace only changes one of the
        several possible ways to get an Enum member from the Enum class,
        resulting in an inconsistent Enumeration.

        rd   zCannot reassign members.N)rN   Úgetr€   r0   Ú__setattr__)r(   r   r.   Z
member_map)r4   r   r   r�   a  s    zEnumMeta.__setattr__c            C   s‚  | j }|dkr| fn|| f}| j|ƒ\}	}
|j||ƒ}t|tƒrP|jddƒjƒ }t|ttfƒrÄ|rÄt|d tƒrÄ|g  }}g }xDt	|ƒD ]8\}}|
j
||||dd… ƒ}|j|ƒ |j||fƒ qˆW x6|D ].}t|tƒrè|||  }}n|\}}|||< qÊW |j||||ƒ}|dk�rTytjdƒjd }W n( ttfk
�rR } zW Y dd}~X nX |dk�rht|ƒ n||_|dk	�r~||_|S )a•  Convenience method to create a new Enum class.

        `names` can be:

        * A string containing member names, separated either with spaces or
          commas.  Values are incremented by 1 from `start`.
        * An iterable of member names.  Values are incremented by 1 from `start`.
        * An iterable of (member name, value) pairs.
        * A mapping of member name -> value pairs.

        NrM   r\   r   r   r*   )r4   rA   rG   r<   rm   rn   ro   ri   ÚlistÚ	enumerater7   r=   rb   ÚsysÚ	_getframeÚ	f_globalsr€   r:   r)   r'   r+   )r(   Z
class_namer|   rw   rx   ry   rz   rC   rD   r   rF   rJ   Zoriginal_namesÚlast_valuesÚcountr   r.   Úitemrt   Úmember_valuerr   Úexcr   r   r   r{   n  s<    
 







zEnumMeta._create_c             C   s´   | st tfS d }}x,| D ]$}|tk	rt|tƒr|jrtdƒ‚qW t|tƒsTtdƒ‚t| d tƒst| d }| d }n8x6| d jD ](}t|tƒrœ|dkr¨|}q€|dkr€|}q€W ||fS )zžReturns the type for creating enum members, and the first inherited
        enum class.

        bases: the tuple of bases that was given to __new__

        NzCannot extend enumerationszHnew enumerations must be created as `ClassName([mixin_type,] enum_type)`r   r   r    )rg   r   Ú
issubclassrc   r"   Ú__mro__)rD   rE   rF   Úbaser   r   r   rA   £  s(    




zEnumMeta._get_mixins_c       	      C   s’   | j ddƒ}|dk	}|dkrtxVdD ]H}x8||fD ],}t||dƒ}|ddjtjtjhkr0|}P q0W |dk	r"P q"W tj}|tjkr„d}nd}|||fS )a  Returns the __new__ to be used for creating the enum members.

        classdict: the class dictionary given to __new__
        member_type: the data type whose __new__ will be used by default
        first_enum: enumeration to check for an overriding __new__

        rb   Nrl   FT)rl   rb   )rŒ   rB   rb   rg   r   )	rJ   rE   rF   rb   rp   ÚmethodZpossibleÚtargetrq   r   r   r   r]   Ð  s(    


zEnumMeta._find_new_)N)r*   r'   r+   r,   ÚclassmethodrG   rb   rv   r}   r   r�   r„   r†   r‡   rˆ   r‰   Úpropertyrƒ   rY   r‹   r�   r{   ÚstaticmethodrA   r]   r@   r   r   )r4   r   r   p   s(   
 

5-c               @   s‚   e Zd ZdZdd„ Zdd„ Zedd„ ƒZdd	„ Zd
d„ Z	dd„ Z
dd„ Zdd„ Zdd„ Zedd„ ƒZedd„ ƒZeddd„ƒZdS )r   zRGeneric enumeration.

    Derive from this class to define new enumerations.

    c             C   sj   t |ƒ| kr|S y|| jkr&| j| S W n6 tk
r^   x | jjƒ D ]}|j|krD|S qDW Y nX | j|ƒS )N)ry   rf   r"   rd   ÚvaluesrX   r8   )r(   r.   r~   r   r   r   rb     s    

zEnum.__new__c             C   s8   x2t |ƒD ]"}y|d S  tk
r*   Y q
X q
W |S d S )Nr   )rŠ   r"   )r   rz   r”   r“   Ú
last_valuer   r   r   r7     s    
zEnum._generate_next_value_c             C   s   t d|| jf ƒ‚d S )Nz%r is not a valid %s)r:   r*   )r(   r.   r   r   r   r8   "  s    zEnum._missing_c             C   s   d| j j| j| jf S )Nz<%s.%s: %r>)r4   r*   rj   rX   )r#   r   r   r   rY   &  s    zEnum.__repr__c             C   s   d| j j| jf S )Nz%s.%s)r4   r*   rj   )r#   r   r   r   rZ   *  s    zEnum.__str__c                s&   ‡ fdd„ˆ j jƒ D ƒ}dddg| S )Nc                s2   g | ]*}|j D ]}|d  dkr|ˆ jkr|‘qqS )r   r   )rN   rd   )rH   r(   rV   )r#   r   r   ú
<listcomp>/  s   
z Enum.__dir__.<locals>.<listcomp>r4   r,   r'   )r4   rL   )r#   Zadded_behaviorr   )r#   r   r„   -  s    
zEnum.__dir__c             C   s0   | j tkrt}t| ƒ}n| j }| j}|j||ƒS )N)re   rg   rm   rX   r[   )r#   Zformat_specr(   Úvalr   r   r   r[   6  s    

zEnum.__format__c             C   s
   t | jƒS )N)Úhashrj   )r#   r   r   r   Ú__hash__E  s    zEnum.__hash__c             C   s   | j | jffS )N)r4   rX   )r#   r$   r   r   r   r&   H  s    zEnum.__reduce_ex__c             C   s   | j S )zThe name of the Enum member.)rj   )r#   r   r   r   r   R  s    z	Enum.namec             C   s   | j S )zThe value of the Enum member.)rX   )r#   r   r   r   r.   W  s    z
Enum.valueNc                sž   t tj| ƒ}ˆrt ˆƒ‰n|‰‡ ‡fdd„ˆjƒ D ƒ}y|jdd„ d� W n$ tk
rp   |jdd„ d� Y nX | |||d�} t| _|j| j	ƒ | ||< | S )z[
        Create a new Enum subclass that replaces a collection of global constants
        c                s    g | ]}ˆ |ƒr|ˆ| f‘qS r   r   )rH   r   )ÚfilterÚsourcer   r   r¢   q  s   z!Enum._convert.<locals>.<listcomp>c             S   s   | d | d fS )Nr   r   r   )Útr   r   r   Ú<lambda>v  s    zEnum._convert.<locals>.<lambda>)r?   c             S   s   | d S )Nr   r   )r¨   r   r   r   r©   y  s    )rw   )
Úvarsr�   ÚmodulesÚkeysÚsortr"   Ú_reduce_ex_by_namer&   Úupdaterƒ   )r(   r   rw   r¦   r§   Zmodule_globalsÚmembersr   )r¦   r§   r   Ú_convert\  s    

zEnum._convert)N)r*   r'   r+   r,   rb   r7   r�   r8   rY   rZ   r„   r[   r¥   r&   r   r   r.   r±   r   r   r   r   r   ÿ  s   		
)Ú	metaclassc               @   s   e Zd ZdZdS )r	   z.Enum where members are also (and must be) intsN)r*   r'   r+   r,   r   r   r   r   r	   �  s   c             C   s   | j S )N)r   )r#   r$   r   r   r   r®   …  s    r®   c               @   sp   e Zd ZdZdd„ Zedd„ ƒZedd„ ƒZdd	„ Zd
d„ Z	dd„ Z
dd„ Zdd„ Zdd„ Zdd„ Zdd„ ZdS )r
   zSupport for flagsc             C   sd   |s|dk	r|S dS xBt |ƒD ]6}yt|ƒ}P W q tk
rR   td| ƒd‚Y qX qW d|d  S )zñ
        Generate the next value when not given.

        name: the name of the member
        start: the initital start value or None
        count: the number of existing members
        last_value: the last value assigned or None
        Nr   zInvalid Flag value: %rr   )rŠ   Ú	_high_bitÚ	Exceptionr"   )r   rz   r”   r“   r¡   Zhigh_bitr   r   r   r7   ‹  s    	zFlag._generate_next_value_c             C   s.   |}|dk r| }| j |ƒ}|dk r*| }|S )Nr   )r6   )r(   r.   Zoriginal_valueZpossible_memberr   r   r   r8   ž  s    
zFlag._missing_c             C   sb   | j j|dƒ}|dkr^t| |ƒ\}}|r:td|| jf ƒ‚tj| ƒ}d|_||_| j j	||ƒ}|S )zL
        Create a composite member iff value contains only members.
        Nz%r is not a valid %s)
rf   rŒ   Ú
_decomposer:   r*   rg   rb   rj   rX   Ú
setdefault)r(   r.   Úpseudo_memberr   Úextra_flagsr   r   r   r6   ¨  s    
zFlag._create_pseudo_member_c             C   s"   t || jƒstS |j| j@ |jkS )N)r<   r4   ÚNotImplementedrX   )r#   Úotherr   r   r   r   ¼  s    zFlag.__contains__c             C   sV   | j }| jd k	r$d|j| j| jf S t|| jƒ\}}d|jdjdd„ |D ƒƒ| jf S )Nz<%s.%s: %r>ú|c             S   s   g | ]}t |jp|jƒ‘qS r   )rm   rj   rX   )rH   rV   r   r   r   r¢   È  s    z!Flag.__repr__.<locals>.<listcomp>)r4   rj   r*   rX   rµ   ra   )r#   r(   r°   Ú	uncoveredr   r   r   rY   Á  s    
zFlag.__repr__c             C   s€   | j }| jd k	r d|j| jf S t|| jƒ\}}t|ƒdkr^|d jd kr^d|j|d jf S d|jdjdd„ |D ƒƒf S d S )Nz%s.%sr   r   z%s.%rr»   c             S   s   g | ]}t |jp|jƒ‘qS r   )rm   rj   rX   )rH   rV   r   r   r   r¢   Ö  s    z Flag.__str__.<locals>.<listcomp>)r4   rj   r*   rµ   rX   r   ra   )r#   r(   r°   r¼   r   r   r   rZ   Ì  s    
zFlag.__str__c             C   s
   t | jƒS )N)ÚboolrX   )r#   r   r   r   rv   Ù  s    zFlag.__bool__c             C   s"   t || jƒstS | j| j|jB ƒS )N)r<   r4   r¹   rX   )r#   rº   r   r   r   Ú__or__Ü  s    zFlag.__or__c             C   s"   t || jƒstS | j| j|j@ ƒS )N)r<   r4   r¹   rX   )r#   rº   r   r   r   Ú__and__á  s    zFlag.__and__c             C   s"   t || jƒstS | j| j|jA ƒS )N)r<   r4   r¹   rX   )r#   rº   r   r   r   Ú__xor__æ  s    zFlag.__xor__c                sD   t ˆjˆjƒ\‰ }‡ ‡fdd„ˆjD ƒ}tt|ˆjdƒƒ}ˆj|ƒS )Nc                s&   g | ]}|ˆ kr|j ˆj @  r|‘qS r   )rX   )rH   rV   )r°   r#   r   r   r¢   î  s    z#Flag.__invert__.<locals>.<listcomp>r   )rµ   r4   rX   r   Ú_or_)r#   r¼   Zinverted_membersZinvertedr   )r°   r#   r   Ú
__invert__ë  s    zFlag.__invert__N)r*   r'   r+   r,   r7   r�   r8   r6   r   rY   rZ   rv   r¾   r¿   rÀ   rÂ   r   r   r   r   r
   ˆ  s   
c               @   sT   e Zd ZdZedd„ ƒZedd„ ƒZdd„ Zdd	„ Zd
d„ Z	eZ
eZe	Zdd„ ZdS )r   zSupport for integer-based Flagsc             C   s*   t |tƒstd|| jf ƒ‚| j|ƒ}|S )Nz%r is not a valid %s)r<   Úintr:   r*   r6   )r(   r.   Z
new_memberr   r   r   r8   ø  s    

zIntFlag._missing_c             C   s´   | j j|d ƒ}|d kr°|g}t| |ƒ\}}xL|rvt|ƒ}d| }|| j kr\||kr\|j|ƒ || krld}q,||N }q,W x6t|ƒD ]*}tj| |ƒ}d |_||_	| j j
||ƒ}q‚W |S )Nr   r   )rf   rŒ   rµ   r³   r=   rŠ   rÃ   rb   rj   rX   r¶   )r(   r.   r·   Zneed_to_creater   r¸   ZbitZ
flag_valuer   r   r   r6   ÿ  s&    


zIntFlag._create_pseudo_member_c             C   s0   t || jtfƒstS | j| j| j|ƒjB ƒ}|S )N)r<   r4   rÃ   r¹   rX   )r#   rº   Úresultr   r   r   r¾     s    zIntFlag.__or__c             C   s,   t || jtfƒstS | j| j| j|ƒj@ ƒS )N)r<   r4   rÃ   r¹   rX   )r#   rº   r   r   r   r¿   #  s    zIntFlag.__and__c             C   s,   t || jtfƒstS | j| j| j|ƒjA ƒS )N)r<   r4   rÃ   r¹   rX   )r#   rº   r   r   r   rÀ   (  s    zIntFlag.__xor__c             C   s   | j | j ƒ}|S )N)r4   rX   )r#   rÄ   r   r   r   rÂ   1  s    zIntFlag.__invert__N)r*   r'   r+   r,   r�   r8   r6   r¾   r¿   rÀ   Ú__ror__Ú__rand__Ú__rxor__rÂ   r   r   r   r   r   õ  s   c             C   s   | j ƒ d S )z@returns index of highest bit, or -1 if value is zero or negativer   )Ú
bit_length)r.   r   r   r   r³   6  s    r³   c             C   sb   g }x0| j jƒ D ]"\}}||jkr|j||jfƒ qW |r^djdd„ |D ƒƒ}td| |f ƒ‚| S )z?Class decorator for enumerations ensuring unique member values.z, c             S   s   g | ]\}}d ||f ‘qS )z%s -> %sr   )rH   Úaliasr   r   r   r   r¢   B  s    zunique.<locals>.<listcomp>z duplicate values found in %r: %s)rƒ   rO   r   r=   ra   r:   )ZenumerationZ
duplicatesr   r~   Zalias_detailsr   r   r   r   :  s    
c             C   sÚ   |}|dk }|r*dd„ t | jjƒ ƒD ƒ}ndd„ t | jjƒ ƒD ƒ}g }x4|D ],\}}|rL||@ |krL|j|ƒ || M }qLW | rœ|| jkrœ|j| j| ƒ |jdd„ dd� t|ƒd	krÒ|d j|krÒ|jdƒ ||fS )
z#Extract all members from the value.r   c             S   s"   g | ]\}}|j d k	r||f‘qS )N)r   )rH   rQ   rV   r   r   r   r¢   R  s   z_decompose.<locals>.<listcomp>c             S   s*   g | ]"\}}|j d k	st|ƒr||f‘qS )N)r   Ú_power_of_two)rH   rQ   rV   r   r   r   r¢   Y  s   c             S   s   | j S )N)rX   )rV   r   r   r   r©   d  s    z_decompose.<locals>.<lambda>T)r?   Úreverser   )rŽ   rf   rO   r=   r­   r   r.   r^   )Zflagr.   Znot_coveredZnegativeZflags_to_checkr°   r~   r–   r   r   r   rµ   G  s$    

rµ   c             C   s   | dk rdS | dt | ƒ kS )Nr   Fr   )r³   )r.   r   r   r   rÊ   j  s    rÊ   )#r�   Útypesr   r   Ú	functoolsr   Úoperatorr   rÁ   Ú_collectionsr   ÚImportErrorÚcollectionsÚ__all__r   r   r!   r)   rg   r-   r   Údictr/   r   ry   r   rÃ   r	   r®   r
   r   r³   r   rµ   rÊ   r   r   r   r   Ú<module>   s@   3    mA#