File: //lib/python3/dist-packages/constantly/__pycache__/_constants.cpython-312.pyc
�
?f�U�> � �T � d Z ddlmZmZ g d�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)�
NamedConstant�
ValueConstant� FlagConstant�Names�Values�Flags)�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__0 �= � � �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__B �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__T 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__f 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._realizex s � � $����� r N) r �
__module__� __qualname__�__doc__r r" r* r- r0 r2 r6 � 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 )�superr< �__new__�getattr�itemsr% r> r �
ValueErrorr �appendr �sorted�_constantFactoryr6 � _enumerants)
r r! �bases�
attributes�cls� constantType� constants�
descriptor�
enumerants�index� enumerantr5 r& s
�r r@ z _ConstantsContainerType.__new__� s �� �$ �+�T�:� �$��z�+��
�s�O�T�:� � � ��J�� �",�"2�"2�"4� �T�:��*�c�&7�&7�8� �(�(�4�$� &�� � �6�7� 7� � � �*�"3�"3�T�:�!F�G�
#5� �
�.4�Y�.?� *�U�I�z��(�(��J�?�E� � � ��Y�� 6�$.�J�y� !� /@� %����
r )r r7 r8 r9 r@ �
__classcell__)r& s @r r< r< � s �� ��/� /r r< 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 )rJ 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)rJ r! rM s r rF 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}.
)rG rA rC )rJ 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 )rM s r �<lambda>z3_ConstantsContainer.iterconstants.<locals>.<lambda> s
� �Z�5F�5Fr )�key)rG �values�iterrE )rJ rL s r �
iterconstantsz!_ConstantsContainer.iterconstants s0 � � �O�O�*�*�,� �� �9�"F� G�I� Ir )
r r7 r8 r9 r> r@ � classmethodrF rY r` r: r r rS rS � sR � � � �M�I� � � � � � � � �$ � I� � Ir rS � c � � e Zd ZdZy)r a
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 r7 r8 r9 r: r r r r s � �r r c � � e Zd ZdZeZy)r ze
A L{Names} subclass contains constants which differ only in their names and
identities.
N)r r7 r8 r9 r r> r: r r r r ! s � �� "�Mr r c � � e Zd ZdZd� Zy)r a
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 r5 �r r5 s r r zValueConstant.__init__2 � � ����4� ���
r N)r r7 r8 r9 r r: r r r r * s � ��r r c �$ � e Zd ZdZeZed� � Zy)r za
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}.
)r` r5 rC )rJ r5 �constants r �
lookupByValuezValues.lookupByValue? s5 � � �)�)�+�H��~�~��&� �� ,� �� � r N)r r7 r8 r9 r r> ra rm r: r r r r 8 s � �� "�M�� � � r r 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.
)r5 �namesr r6 r )�op�left�rightr5 ro �results r �_flagOprt S 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 ) r 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 rg rh s r r zFlagConstant.__init__p ri 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�joinrE r r6 r5 ro )r r4 ro r5 r! s r r6 zFlagConstant._realizeu 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.
)rt 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.
)rt 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.
)rt 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 )r r6 r r} r` r5 )r rs �flags r �
__invert__zFlagConstant.__invert__� s] � �
� �����������2��O�O�1�1�3�D��z�z�D�J�J�&�!�+��$��� 4� �
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 rY )�.0r! r s �r � <genexpr>z(FlagConstant.__iter__.<locals>.<genexpr>� s! �� �� �J�z�t����,�,�T�2�z�s �%()ro 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� r5 r s r � __nonzero__zFlagConstant.__nonzero__� s � � �D�J�J� � r N)r r7 r8 r9 rW r r6 r� r� r� r� r� r� r� �__bool__r: r r r r h sA � �� *� �
�<)�*�)�
�K� !� �
�Hr r c �( � e Zd ZdZeZdZed� � Zy)r
z�
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.
rx 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}.
rx )r5 rW �_value)rJ r! rM r5 s r rF zFlags._constantFactory� sM � � � � �|� +��J�J�E� �J�J�1� �J� � � �$�$�E� �!��C�J�� r N) r r7 r8 r9 r r> r� ra rF r: r r r
r
� s% � ��
!�M�
�F��� �r r
N) r9 �
__future__r r �__all__� functoolsr � itertoolsr �operatorr
r r �objectrW �nextr r �typer< rS r r r r rt r r
r: 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