| Current File : //proc/self/root/usr/lib/python3/dist-packages/constantly/__pycache__/_constants.cpython-312.pyc |
�
?��^�> � �P � d Z ddlmZmZ g ZddlmZ ddlmZ ddl m
Z
m Z m Z e
� Z ee e� � Z G d� de
� Z G d� d e� Z G d
� d ed e
fi � � Z G d
� de� Z G d� de� Z G d� de� Z G d� de� Zd� Z G d� de� Z G d� de� Zy)zi
Symbolic constant support, including collections and constants with text,
numeric, and bit flag values.
� )�division�absolute_import)�partial)�count)�and_�or_�xorc �: � e Zd ZdZd� Zd� Zd� Zd� Zd� Zd� Z d� Z
y )
� _Constanta�
@ivar _index: A C{int} allocated from a shared counter in order to keep
track of the order in which L{_Constant}s are instantiated.
@ivar name: A C{str} giving the name of this constant; only set once the
constant is initialized by L{_ConstantsContainer}.
@ivar _container: The L{_ConstantsContainer} subclass this constant belongs
to; C{None} until the constant is initialized by that subclass.
c �0 � d | _ t � | _ y �N)�
_container�_constantOrder�_index��selfs �7/usr/lib/python3/dist-packages/constantly/_constants.py�__init__z_Constant.__init__! s � � ���$�&�� � c �P � d| j j �d| j �d�S )zq
Return text identifying both which constant this is and which
collection it belongs to.
�<�=�>)r �__name__�namer s r �__repr__z_Constant.__repr__& s � �
!�O�O� 4� 4�d�i�i�@�@r c � � t || j � r| j |j k( st S | j |j k S )aC
Implements C{<}. Order is defined by instantiation order.
@param other: An object.
@return: C{NotImplemented} if C{other} is not a constant belonging to
the same container as this constant, C{True} if this constant is
defined before C{other}, otherwise C{False}.
��
isinstance� __class__r �NotImplementedr �r �others r �__lt__z_Constant.__lt__. �= � � �5�$�.�.�1����5�#3�#3�3�!� !��{�{�U�\�\�)�)r c � � t || j � r| j |j k( st S | |u xs | j |j k S )aP
Implements C{<=}. Order is defined by instantiation order.
@param other: An object.
@return: C{NotImplemented} if C{other} is not a constant belonging to
the same container as this constant, C{True} if this constant is
defined before or equal to C{other}, otherwise C{False}.
r r" s r �__le__z_Constant.__le__@ �F � � �5�$�.�.�1����5�#3�#3�3�!� !��u�}�:�� � �e�l�l� :�:r c � � t || j � r| j |j k( st S | j |j kD S )aB
Implements C{>}. Order is defined by instantiation order.
@param other: An object.
@return: C{NotImplemented} if C{other} is not a constant belonging to
the same container as this constant, C{True} if this constant is
defined after C{other}, otherwise C{False}.
r r" s r �__gt__z_Constant.__gt__R r% r c � � t || j � r| j |j k( st S | |u xs | j |j kD S )aO
Implements C{>=}. Order is defined by instantiation order.
@param other: An object.
@return: C{NotImplemented} if C{other} is not a constant belonging to
the same container as this constant, C{True} if this constant is
defined after or equal to C{other}, otherwise C{False}.
r r" s r �__ge__z_Constant.__ge__d r( r c � � || _ || _ y)ao
Complete the initialization of this L{_Constant}.
@param container: The L{_ConstantsContainer} subclass this constant is
part of.
@param name: The name of this constant in its container.
@param value: The value of this constant; not used, as named constants
have no value apart from their identity.
N)r r )r � containerr �values r �_realizez_Constant._realizev s � � $����� r N) r �
__module__� __qualname__�__doc__r r r$ r' r* r, r0 � r r r r s+ � � �'�
A�*�$;�$*�$;�$
r r c �" � � e Zd ZdZ� fd�Z� xZS )�_ConstantsContainerTypeza
L{_ConstantsContainerType} is a metaclass for creating constants container
classes.
c �� �� t t | � | |||� }t |dd� }|�|S g }|j � D ]a \ }}t ||j � s� |j �t d|�d|j ��� �|j |j ||f� �c i }t |� D ]0 \ } }
}|j |
|� } |j ||
| � |||
< �2 ||_ |S )a�
Create a new constants container class.
If C{attributes} includes a value of C{None} for the C{"_constantType"}
key, the new class will not be initialized as a constants container and
it will behave as a normal class.
@param name: The name of the container class.
@type name: L{str}
@param bases: A tuple of the base classes for the new container class.
@type bases: L{tuple} of L{_ConstantsContainerType} instances
@param attributes: The attributes of the new container class, including
any constants it is to contain.
@type attributes: L{dict}
�
_constantTypeNz Cannot use z! as the value of an attribute on )�superr6 �__new__�getattr�itemsr r8 r �
ValueErrorr �appendr �sorted�_constantFactoryr0 � _enumerants)
r r �bases�
attributes�cls� constantType� constants�
descriptor�
enumerants�index� enumerantr/ r s
�r r: z _ConstantsContainerType.__new__� s �� �$ �+�T�:� �$��z�+��
�s�O�T�:� � � ��J�� �",�"2�"2�"4� H� �T�:��*�c�&7�&7�8� �(�(�4�$� &�� � �6�7� 7� � � �*�"3�"3�T�:�!F�G�
H� �
�.4�Y�.?� /� *�U�I�z��(�(��J�?�E� � � ��Y�� 6�$.�J�y� !� /� %����
r )r r1 r2 r3 r: �
__classcell__)r s @r r6 r6 � s �� ��/� /r r6 c �J � e Zd ZdZdZd� Zed� � Zed� � Zed� � Z y)�_ConstantsContainera�
L{_ConstantsContainer} is a class with attributes used as symbolic
constants. It is up to subclasses to specify what kind of constants are
allowed.
@cvar _constantType: Specified by a L{_ConstantsContainer} subclass to
specify the type of constants allowed by that subclass.
@cvar _enumerants: A C{dict} mapping the names of constants (eg
L{NamedConstant} instances) found in the class definition to those
instances.
Nc �2 � t | j �d�� �)z�
Classes representing constants containers are not intended to be
instantiated.
The class object itself is used directly.
z may not be instantiated.)� TypeErrorr )rD s r r: z_ConstantsContainer.__new__� s � � �� � �G�H�Hr c � � t S )a�
Construct the value for a new constant to add to this container.
@param name: The name of the constant to create.
@param descriptor: An instance of a L{_Constant} subclass (eg
L{NamedConstant}) which is assigned to C{name}.
@return: L{NamedConstant} instances have no value apart from identity,
so return a meaningless dummy value.
)� _unspecified)rD r rG s r r@ z$_ConstantsContainer._constantFactory� s
� � �r c �L � || j v r t | |� S t |� �)a�
Retrieve a constant by its name or raise a C{ValueError} if there is no
constant associated with that name.
@param name: A C{str} giving the name of one of the constants defined
by C{cls}.
@raise ValueError: If C{name} is not the name of one of the constants
defined by C{cls}.
@return: The L{NamedConstant} associated with C{name}.
)rA r; r= )rD r s r � lookupByNamez _ConstantsContainer.lookupByName� s( � � �3�?�?� "��3��%� %��� � r c �d � | j j � }t t |d� �� � S )z�
Iteration over a L{Names} subclass results in all of the constants it
contains.
@return: an iterator the elements of which are the L{NamedConstant}
instances defined in the body of this L{Names} subclass.
c � � | j S r
)r )rG s r �<lambda>z3_ConstantsContainer.iterconstants.<locals>.<lambda> s � �Z�5F�5F� r )�key)rA �values�iterr? )rD rF s r �
iterconstantsz!_ConstantsContainer.iterconstants s0 � � �O�O�*�*�,� �� �9�"F� G�I� Ir )
r r1 r2 r3 r8 r: � classmethodr@ rS rZ r4 r r rM rM � sR � � � �M�I� � � � � � � � �$ � I� � Ir rM � c � � e Zd ZdZy)�
NamedConstanta
L{NamedConstant} defines an attribute to be a named constant within a
collection defined by a L{Names} subclass.
L{NamedConstant} is only for use in the definition of L{Names}
subclasses. Do not instantiate L{NamedConstant} elsewhere and do not
subclass it.
N)r r1 r2 r3 r4 r r r^ r^ s � �r r^ c � � e Zd ZdZeZy)�Namesze
A L{Names} subclass contains constants which differ only in their names and
identities.
N)r r1 r2 r3 r^ r8 r4 r r r` r` s � �� "�Mr r` c � � e Zd ZdZd� Zy)�
ValueConstanta
L{ValueConstant} defines an attribute to be a named constant within a
collection defined by a L{Values} subclass.
L{ValueConstant} is only for use in the definition of L{Values} subclasses.
Do not instantiate L{ValueConstant} elsewhere and do not subclass it.
c �< � t j | � || _ y r
�r r r/ �r r/ s r r zValueConstant.__init__0 � � ����4� ���
r N)r r1 r2 r3 r r4 r r rb rb ( s � ��r rb c �$ � e Zd ZdZeZed� � Zy)�Valuesza
A L{Values} subclass contains constants which are associated with arbitrary
values.
c �h � | j � D ] }|j |k( s�|c S t |� �)a�
Retrieve a constant by its value or raise a C{ValueError} if there is
no constant associated with that value.
@param value: The value of one of the constants defined by C{cls}.
@raise ValueError: If C{value} is not the value of one of the constants
defined by C{cls}.
@return: The L{ValueConstant} associated with C{value}.
)rZ r/ r= )rD r/ �constants r �
lookupByValuezValues.lookupByValue= s: � � �)�)�+� �H��~�~��&� �� � �� � r N)r r1 r2 r3 rb r8 r[ rk r4 r r rh rh 6 s � �� "�M�� � � r rh c �� � | |j |j � } | |j |j � }t � }|j |j ||� |S )a�
Implement a binary operator for a L{FlagConstant} instance.
@param op: A two-argument callable implementing the binary operation. For
example, C{operator.or_}.
@param left: The left-hand L{FlagConstant} instance.
@param right: The right-hand L{FlagConstant} instance.
@return: A new L{FlagConstant} instance representing the result of the
operation.
)r/ �names� FlagConstantr0 r )�op�left�rightr/ rm �results r �_flagOprs Q sL � �
�t�z�z�5�;�;� '�E� �t�z�z�5�;�;� '�E�
�^�F�
�O�O�D�O�O�U�E�2� �Mr c �N � e Zd ZdZefd�Zd� Zd� Zd� Zd� Z d� Z
d� Z d � Z d
� Z
e
Zy ) rn a
L{FlagConstant} defines an attribute to be a flag constant within a
collection defined by a L{Flags} subclass.
L{FlagConstant} is only for use in the definition of L{Flags} subclasses.
Do not instantiate L{FlagConstant} elsewhere and do not subclass it.
c �< � t j | � || _ y r
rd re s r r zFlagConstant.__init__n rf r c �� � t |t � r|}t |g� }n3t |� dk( r|\ }n ddj t |� � z dz }t j | |||� || _ || _ y)aR
Complete the initialization of this L{FlagConstant}.
This implementation differs from other C{_realize} implementations in
that a L{FlagConstant} may have several names which apply to it, due to
flags being combined with various operators.
@param container: The L{Flags} subclass this constant is part of.
@param names: When a single-flag value is being initialized, a C{str}
giving the name of that flag. This is the case which happens when
a L{Flags} subclass is being initialized and L{FlagConstant}
instances from its body are being realized. Otherwise, a C{set} of
C{str} giving names of all the flags set on this L{FlagConstant}
instance. This is the case when two flags are combined using C{|},
for example.
� �{�,�}N)
r �str�set�len�joinr? r r0 r/ rm )r r. rm r/ r s r r0 zFlagConstant._realizes sn � �$ �e�S� !��D����L�E�
��Z�1�_��G�T�����&��-�0�0�3�6�D����4��D�%�8���
���
r c �$ � t t | |� S )z�
Define C{|} on two L{FlagConstant} instances to create a new
L{FlagConstant} instance with all flags set in either instance set.
)rs r r" s r �__or__zFlagConstant.__or__� s � �
�s�D�%�(�(r c �$ � t t | |� S )z�
Define C{&} on two L{FlagConstant} instances to create a new
L{FlagConstant} instance with only flags set in both instances set.
)rs r r" s r �__and__zFlagConstant.__and__� s � �
�t�T�5�)�)r c �$ � t t | |� S )z�
Define C{^} on two L{FlagConstant} instances to create a new
L{FlagConstant} instance with only flags set on exactly one instance
set.
)rs r r" s r �__xor__zFlagConstant.__xor__� s � � �s�D�%�(�(r c �� � t � }|j | j t � d� | j j � D ]$ }|j
| j
z dk( s� ||z }�& |S )z�
Define C{~} on a L{FlagConstant} instance to create a new
L{FlagConstant} instance with all flags not set on this instance set.
r )rn r0 r r| rZ r/ )r rr �flags r �
__invert__zFlagConstant.__invert__� sb � �
� �����������2��O�O�1�1�3� �D��z�z�D�J�J�&�!�+��$��� � �
r c �. � � � fd�� j D � S )zI
@return: An iterator of flags set on this instance set.
c 3 �T �K � | ] }�j j |� �� �! y �wr
)r rS )�.0r r s �r � <genexpr>z(FlagConstant.__iter__.<locals>.<genexpr>� s �� �� �J�t����,�,�T�2�J�s �%()rm r s `r �__iter__zFlagConstant.__iter__� s �� � K�t�z�z�J�Jr c � � t || z � S )z�
@param flag: The flag to test for membership in this instance
set.
@return: C{True} if C{flag} is in this instance set, else
C{False}.
)�bool)r r� s r � __contains__zFlagConstant.__contains__� s � � �D�4�K� � r c �, � t | j � S )zL
@return: C{False} if this flag's value is 0, else C{True}.
)r� r/ r s r � __nonzero__zFlagConstant.__nonzero__� s � � �D�J�J� � r N)r r1 r2 r3 rQ r r0 r� r� r� r� r� r� r� �__bool__r4 r r rn rn f sA � �� *� �
�<)�*�)�
�K� !� �
�Hr rn c �( � e Zd ZdZeZdZed� � Zy)�Flagsz�
A L{Flags} subclass contains constants which can be combined using the
common bitwise operators (C{|}, C{&}, etc) similar to a I{bitvector} from a
language like C.
rw c � � |j t u r#| j }| xj dz c_ |S |j }|dz | _ |S )a
For L{FlagConstant} instances with no explicitly defined value, assign
the next power of two as its value.
@param name: The name of the constant to create.
@param descriptor: An instance of a L{FlagConstant} which is assigned
to C{name}.
@return: Either the value passed to the C{descriptor} constructor, or
the next power of 2 value which will be assigned to C{descriptor},
relative to the value of the last defined L{FlagConstant}.
rw )r/ rQ �_value)rD r rG r/ s r r@ zFlags._constantFactory� sM � � � � �|� +��J�J�E� �J�J�1� �J� � � �$�$�E� �!��C�J�� r N) r r1 r2 r3 rn r8 r� r[ r@ r4 r r r� r� � s% � ��
!�M�
�F��� �r r� N) r3 �
__future__r r �__all__� functoolsr � itertoolsr �operatorr r r �objectrQ �nextr r �typer6 rM r^ r` rb rh rs rn r� r4 r r �<module>r� s� ��
�
1�
�� � � #� #��x� ���u�w�'��m�� m�b4�d� 4�~II�1�"�v�i��D� II�Z�I� �"� � "�
�I�
� �
� �6�*i�9� i�Z �F� r