Sf> dZddlmZmZgZddlmZddlmZddl m Z m Z m Z e ZeeeZGdde ZGdd eZGd d ed e fiZGd deZGddeZGddeZGddeZdZGddeZGddeZdS)zi Symbolic constant support, including collections and constants with text, numeric, and bit flag values. )divisionabsolute_import)partial)count)and_or_xorc<eZdZdZdZdZdZdZdZdZ dZ d S) _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:d|_t|_dSN) _container_constantOrder_indexselfs G/var/www/html/env/lib/python3.11/site-packages/constantly/_constants.py__init__z_Constant.__init__!s$&& c2d|jjd|jdS)zq Return text identifying both which constant this is and which collection it belongs to. <=>)r__name__namers r__repr__z_Constant.__repr__&s" !O444diii@@rczt||jr|j|jkstS|j|jkS)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__rNotImplementedrrothers r__lt__z_Constant.__lt__.=5$.11 "5#333! !{U\))rct||jr|j|jkstS||up|j|jkS)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}. rr"s r__le__z_Constant.__le__@F5$.11 "5#333! !u}: el ::rczt||jr|j|jkstS|j|jkS)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}. rr"s r__gt__z_Constant.__gt__Rr%rct||jr|j|jkstS||up|j|jkS)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}. rr"s r__ge__z_Constant.__ge__dr(rc"||_||_dS)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)rr)r containerrvalues r_realizez_Constant._realizevs$ rN) r __module__ __qualname____doc__rrr$r'r*r,r0rrr r s  ''' AAA***$;;;$***$;;;$     rr c"eZdZdZfdZxZS)_ConstantsContainerTypeza L{_ConstantsContainerType} is a metaclass for creating constants container classes. ctt|||||}t|dd}||Sg}|D]X\}}t ||jr>|jtd|d|j | |j ||fYi}t|D]8\} } }| | |} ||| | ||| <9||_|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__getattritemsrr8r ValueErrorrappendrsorted_constantFactoryr0 _enumerants) rrbases attributescls constantType constants descriptor enumerantsindex enumerantr/r s rr:z_ConstantsContainerType.__new__sD$+T22:: $z++ sOT::  J ","2"2"4"4 H H T:*c&788 H(4$*&JJ 6777  *"3T:!FGGG .4Y.?.? / / *UIz((J??E   Y 6 6 6$.Jy ! ! % r)rr1r2r3r: __classcell__)r s@rr6r6sB/////////rr6c^eZdZdZdZdZedZedZedZ dS)_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. Nc0t|jd)z Classes representing constants containers are not intended to be instantiated. The class object itself is used directly. z may not be instantiated.) TypeErrorr)rDs rr:z_ConstantsContainer.__new__sGHHHrctS)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)rDrrGs rr@z$_ConstantsContainer._constantFactorys rcR||jvrt||St|)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}. )rAr;r=)rDrs r lookupByNamez _ConstantsContainer.lookupByNames/ 3? " "3%% %rcr|j}tt|dS)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|jSr )r)rGs rz3_ConstantsContainer.iterconstants..s Z5Fr)key)rAvaluesiterr?)rDrFs r iterconstantsz!_ConstantsContainer.iterconstantss@O**,,  9"F"F G G GII Ir) rr1r2r3r8r: classmethodr@rSrZr4rrrMrMs  MIII  [ [$ I I[ I I IrrMceZdZdZdS) 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)rr1r2r3r4rrr^r^srr^ceZdZdZeZdS)Namesze A L{Names} subclass contains constants which differ only in their names and identities. N)rr1r2r3r^r8r4rrr`r`s"MMMrr`ceZdZdZdZdS) 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. cHt|||_dSr r rr/rr/s rrzValueConstant.__init__0!4    rN)rr1r2r3rr4rrrbrb(s-rrbc,eZdZdZeZedZdS)Valuesza A L{Values} subclass contains constants which are associated with arbitrary values. cl|D]}|j|kr|cSt|)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}. )rZr/r=)rDr/constants r lookupByValuezValues.lookupByValue=sH))++  H~&&'rN)rr1r2r3rbr8r[rkr4rrrhrh6s>"M  [   rrhc||j|j}||j|j}t}||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 FlagConstantr0r)opleftrightr/rmresults r_flagOprsQsT Btz5; ' 'E Btz5; ' 'E ^^F OODOUE222 MrcPeZdZdZefdZdZdZdZdZ dZ dZ d Z d Z e Zd S) rna 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. cHt|||_dSr rdres rrzFlagConstant.__init__nrfrc,t|tr|}t|g}n@t|dkr|\}n(ddt |zdz}t ||||||_||_ dS)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) rstrsetlenjoinr?r r0r/rm)rr.rmr/rs rr0zFlagConstant._realizess$ eS ! ! 7DLLEE ZZ1__GTT&--00036D4D%888  rc.tt||S)z Define C{|} on two L{FlagConstant} instances to create a new L{FlagConstant} instance with all flags set in either instance set. )rsrr"s r__or__zFlagConstant.__or__s sD%(((rc.tt||S)z Define C{&} on two L{FlagConstant} instances to create a new L{FlagConstant} instance with only flags set in both instances set. )rsrr"s r__and__zFlagConstant.__and__s tT5)))rc.tt||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. )rsr r"s r__xor__zFlagConstant.__xor__s sD%(((rct}||jtd|jD]}|j|jzdkr||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)rnr0rr|rZr/)rrrflags r __invert__zFlagConstant.__invert__si 222O1133  DzDJ&!++$ rc*fdjDS)zI @return: An iterator of flags set on this instance set. c3LK|]}j|VdSr )rrS).0rrs r z(FlagConstant.__iter__..s3JJt,,T22JJJJJJr)rmrs`r__iter__zFlagConstant.__iter__s"KJJJtzJJJJrc&t||zS)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)rrs r __contains__zFlagConstant.__contains__sD4K   rc*t|jS)zL @return: C{False} if this flag's value is 0, else C{True}. )rr/rs r __nonzero__zFlagConstant.__nonzero__sDJrN)rr1r2r3rQrr0rrrrrrr__bool__r4rrrnrnfs* <)))***)))   KKK ! ! !   HHHrrnc0eZdZdZeZdZedZdS)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. rwct|jtur|j}|xjdzc_n|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)rDrrGr/s rr@zFlags._constantFactorysC  | + +JE JJ1 JJJ$E!CJ rN) rr1r2r3rnr8rr[r@r4rrrrsC !M F[rrN)r3 __future__rr__all__ functoolsr itertoolsroperatorrrr objectrQnextrr typer6rMr^r`rbrhrsrnrr4rrrs]  10000000 ##########vxx uuww''mmmmmmmmb44444d444~IIIIIIIIII11"viDDIIIIIIZI""""" """     I           6*iiiii9iiiZFr