| Server IP : 178.105.222.151 / Your IP : 216.73.216.38 Web Server : nginx/1.28.3 System : Linux MNK 7.0.0-15-generic #15-Ubuntu SMP PREEMPT_DYNAMIC Wed Apr 22 16:06:43 UTC 2026 x86_64 User : www-data ( 33) PHP Version : 8.5.4 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /lib/python3/dist-packages/constantly/__pycache__/ |
Upload File : |
+
��3i�> � �R � R t ^ RIHtHt . t^ RIHt ^ RIHt ^ RI H
t
H t H t ]
! 4 t]! ]]! 4 4 t ! R R]
4 t ! R R]4 t ! R R
]! R ]
3/ 4 4 t ! R R
]4 t ! R R]4 t ! R R]4 t ! R R]4 tR t ! R R]4 t ! R R]4 tR# )zi
Symbolic constant support, including collections and constants with text,
numeric, and bit flag values.
)�division�absolute_import)�partial)�count)�and_�or_�xorc �N a � ] tR t^t o RtR tR tR tR tR t R t
R t R t V t
R
# ) � _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 �2 � R V n \ 4 V n R # �N)�
_container�_constantOrder�_index��selfs &�7/usr/lib/python3/dist-packages/constantly/_constants.py�__init__�_Constant.__init__! s � � ���$�&�� � c �T � RV P P : RV P : R2# )zY
Return text identifying both which constant this is and which
collection it belongs to.
�<�=�>)r
�__name__�namer s &r �__repr__�_Constant.__repr__& s � �
!�O�O� 4� 4�d�i�i�@�@r c � � \ WP 4 ' d V P VP 8X g \ # V P VP 8 # )a
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__�_Constant.__lt__. �> � � �5�.�.�1�1����5�#3�#3�3�!� !��{�{�U�\�\�)�)r c �� � \ WP 4 ' d V P VP 8X g \ # WJ ;' g V P VP 8 # )a
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__�_Constant.__le__@ �H � � �5�.�.�1�1����5�#3�#3�3�!� !��}�:�:�� � �e�l�l� :�:r c � � \ WP 4 ' d V P VP 8X g \ # V P VP 8� # )a
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__�_Constant.__gt__R r' r c �� � \ WP 4 ' d V P VP 8X g \ # WJ ;' g V P VP 8� # )a
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__�_Constant.__ge__d r+ r c � � Wn W n R# )a7
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 �_realize�_Constant._realizev s � � $��� r )r
r r N)r �
__module__� __qualname__�__firstlineno__�__doc__r r r% r) r- r0 r5 �__static_attributes__�__classdictcell__��
__classdict__s @r r
r
s3 �� � � �'�
A�*�$;�$*�$;�$
�
r r
c �6 a a� ] tR t^�t oRtV 3R ltRtVtV ;t# )�_ConstantsContainerTypezU
L{_ConstantsContainerType} is a metaclass for creating constants container
classes.
c �� <� \ \ V ` WW#4 p\ VRR4 pVf V# . pVP 4 Fj w r\ WtP 4 ' g K" VP e \ RV: RVP : 24 hVP VP W34 Kl / p\ V4 F- w r�pVP W�4 p VP WJV 4 WxV
& K/ W�n V# )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 rB r
�
ValueErrorr �appendr �sorted�_constantFactoryr5 � _enumerants)
r r �bases�
attributes�cls� constantType� constants�
descriptor�
enumerants�index� enumerantr4 r! s
&&&& �r rD � _ConstantsContainerType.__new__� s� �� �$ �+�T�:� ��+��
�s�O�T�:� � � ��J�� �",�"2�"2�"4� �T��*�&7�&7�8�8� �(�(�4�$� &�� � �6�7� 7� � � �*�"3�"3�T�!F�G�
#5� �
�.4�Y�.?� *�U�z��(�(��?�E� � � ��� 6�$.�y� !� /@� %���
r � ) r r7 r8 r9 r: rD r; r< �
__classcell__)r! r> s @@r r@ r@ � s �� � ��/� /r r@ c �^ a � ] tR t^�t o RtRtR t]R 4 t]R 4 t ]R 4 t
Rt V t R# )�_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 �4 � \ V P : R24 h)z{
Classes representing constants containers are not intended to be
instantiated.
The class object itself is used directly.
z may not be instantiated.)� TypeErrorr )rN s &r rD �_ConstantsContainer.__new__� s � � �� � �G�H�Hr c � � \ # )aX
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)rN r rQ s &&&r rJ �$_ConstantsContainer._constantFactory� s
� � �r c �N � WP 9 d \ W4 # \ V4 h)aY
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}.
)rK rE rG )rN r s &&r � lookupByName� _ConstantsContainer.lookupByName� s$ � � �?�?� "��3�%� %��� � r c �d � V P P 4 p\ \ VR R7 4 # )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 � � V P # r )r )rQ s &r �<lambda>�3_ConstantsContainer.iterconstants.<locals>.<lambda> s
� �Z�5F�5Fr )�key)rK �values�iterrI )rN rP s & r �
iterconstants�!_ConstantsContainer.iterconstants s0 � � �O�O�*�*�,� �� �9�"F� G�I� Ir rV )
r r7 r8 r9 r: rB rD � classmethodrJ ra rj r; r< r= s @r rY rY � sU �� � � � �M�I� � � � � � � � �$ � I� � Ir rY � c � � ] tR tRtRtRtR# )�
NamedConstanti 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.
rV N)r r7 r8 r9 r: r; rV r r ro ro s � �r ro c � � ] tR tRtRt]tRtR# )�Namesi zY
A L{Names} subclass contains constants which differ only in their names and
identities.
rV N)r r7 r8 r9 r: ro rB r; rV r r rq rq s � �� "�Mr rq c �* a � ] tR tRt o RtR tRtV tR# )�
ValueConstanti( 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 �< � \ P V 4 Wn R # r �r
r r4 �r r4 s &&r r �ValueConstant.__init__0 � � ����4� ��
r )r4 N)r r7 r8 r9 r: r r; r< r= s @r rs rs ( s �� � ��� r rs c �8 a � ] tR tRt o Rt]t]R 4 tRt V t
R# )�Valuesi6 zU
A L{Values} subclass contains constants which are associated with arbitrary
values.
c �p � V P 4 F pVP V8X g K Vu # \ V4 h)aL
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}.
)rj r4 rG )rN r4 �constants && r �
lookupByValue�Values.lookupByValue= s5 � � �)�)�+�H��~�~��&� �� ,� �� � r rV N) r r7 r8 r9 r: rs rB rl r} r; r< r= s @r rz rz 6 s# �� � �� "�M�� � � r rz c �� � V ! VP VP 4 pV ! VP VP 4 p\ 4 pVP VP WC4 V# )ak
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.
)r4 �names� FlagConstantr5 r
)�op�left�rightr4 r� �results &&& r �_flagOpr� Q sJ � �
�t�z�z�5�;�;� '�E� �t�z�z�5�;�;� '�E�
�^�F�
�O�O�D�O�O�U�2� �Mr c �d a � ] tR tRt o Rt]3R ltR tR tR t R t
R t R t R
t
R t]tR tV tR
# )r� if 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 �< � \ P V 4 Wn R # r ru rv s &&r r �FlagConstant.__init__n rx r c � � \ V\ 4 ' d Tp\ V.4 pM=\ V4 ^8X d Vw pM(RRP \ V4 4 , R, p\ P WWC4 W0n W n R# )a�
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�joinrI r
r5 r4 r� )r r3 r� r4 r s &&&& r r5 �FlagConstant._realizes si � �$ �e�S� !� !��D����L�E�
��Z�1�_��G�T�����&��-�0�0�3�6�D����4�D�8��
��
r c �" � \ \ W4 # )z�
Define C{|} on two L{FlagConstant} instances to create a new
L{FlagConstant} instance with all flags set in either instance set.
)r� r r# s &&r �__or__�FlagConstant.__or__� s � �
�s�D�(�(r c �" � \ \ W4 # )z�
Define C{&} on two L{FlagConstant} instances to create a new
L{FlagConstant} instance with only flags set in both instances set.
)r� r r# s &&r �__and__�FlagConstant.__and__� s � �
�t�T�)�)r c �" � \ \ W4 # )z�
Define C{^} on two L{FlagConstant} instances to create a new
L{FlagConstant} instance with only flags set on exactly one instance
set.
)r� r r# s &&r �__xor__�FlagConstant.__xor__� s � � �s�D�(�(r c � � \ 4 pVP V P \ 4 ^ 4 V P P 4 F/ pVP
V P
, ^ 8X g K' W, pK1 V# )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� r5 r
r� rj r4 )r r� �flags & r �
__invert__�FlagConstant.__invert__� s[ � �
� �����������2��O�O�1�1�3�D��z�z�D�J�J�&�!�+���� 4� �
r c �0 a � V 3R lS P 4 # )z9
@return: An iterator of flags set on this instance set.
c 3 �Z <" � T F pSP P V4 x � K" R # 5ir )r
ra )�.0r r s & �r � <genexpr>�(FlagConstant.__iter__.<locals>.<genexpr>� s# �� � �J�z�t����,�,�T�2�2�z�s �(+)r� r s fr �__iter__�FlagConstant.__iter__� s �� � K�t�z�z�J�Jr c �$ � \ W, 4 # )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__�FlagConstant.__contains__� s � � �D�K� � r c �, � \ V P 4 # )z<
@return: C{False} if this flag's value is 0, else C{True}.
)r� r4 r s &r � __nonzero__�FlagConstant.__nonzero__� s � � �D�J�J� � r )r� r4 N)r r7 r8 r9 r: r^ r r5 r� r� r� r� r� r� r� �__bool__r; r< r= s @r r� r� f sD �� � �� *� �
�<)�*�)�
�K� !� �
�Hr r� c �< a � ] tR tRt o Rt]t^t]R 4 t Rt
V t R# )�Flagsi� 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.
c � � VP \ J d( V P pV ;P ^, un V# VP pV^, V n V# )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}.
)r4 r^ �_value)rN r rQ r4 s &&& r rJ �Flags._constantFactory� sM � � � � �|� +��J�J�E� �J�J�1� �J� � � �$�$�E� �!��C�J�� r rV N) r r7 r8 r9 r: r� rB r� rl rJ r; r< r= s @r r� r� � s( �� � ��
!�M�
�F��� �r r� N) r: �
__future__r r �__all__� functoolsr � itertoolsr �operatorr r r �objectr^ �nextr r
�typer@ rY ro rq rs rz r� r� r� rV 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