+ 3i> RRt^RIHtHt.t^RIHt^RIHt^RI H t H t H t ] !4t]!]]!44t!RR] 4t!RR]4t!R R ]!R ] 3/44t!R R ]4t!RR]4t!RR]4t!RR]4tRt!RR]4t!RR]4tR#)zi Symbolic constant support, including collections and constants with text, numeric, and bit flag values. )divisionabsolute_import)partial)count)and_or_xorcNa]tRt^toRtRtRtRtRtRt Rt Rt R t Vt 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. c2RVn\4VnR#N) _container_constantOrder_indexselfs&7/usr/lib/python3/dist-packages/constantly/_constants.py__init___Constant.__init__!s$& c TRVPP: RVP: R2#)zY Return text identifying both which constant this is and which collection it belongs to. <=>)r __name__namers&r__repr___Constant.__repr__&s !OO44dii@@rc \WP4'dVPVP8Xg\#VPVP8#)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 NotImplementedrrothers&&r__lt___Constant.__lt__.>5..115#3#33! !{{U\\))rc \WP4'dVPVP8Xg\#WJ;'gVPVP8#)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}. rr#s&&r__le___Constant.__le__@H5..115#3#33! !}:: ell ::rc \WP4'dVPVP8Xg\#VPVP8#)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}. rr#s&&r__gt___Constant.__gt__Rr'rc \WP4'dVPVP8Xg\#WJ;'gVPVP8#)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}. rr#s&&r__ge___Constant.__ge__dr+rc WnW nR#)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 containerrvalues&&&&r_realize_Constant._realizevs$ r)r rrN)r __module__ __qualname____firstlineno____doc__rrr%r)r-r0r5__static_attributes____classdictcell__ __classdict__s@rr r s3 ' A*$;$*$;$  rr c6aa]tRt^toRtV3RltRtVtV;t#)_ConstantsContainerTypezU L{_ConstantsContainerType} is a metaclass for creating constants container classes. c <\\V` WW#4p\VRR4pVfV#.pVP 4Fjwr\ WtP 4'gK"VPe\RV: RVP: 24hVPVPW34Kl /p\V4F-wrpVPW4p VPWJV 4WxV &K/ WnV#)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__getattritemsr rBr ValueErrorrappendrsorted_constantFactoryr5 _enumerants) rrbases attributescls constantType constants descriptor enumerantsindex enumerantr4r!s &&&& rrD_ConstantsContainerType.__new__s$+T: + sOT:  J ","2"2"4 T*&7&788((4$& 677  *"3"3T!FG #5 .4Y.? *Uz((?E    6$.y !/@% r) rr7r8r9r:rDr;r< __classcell__)r!r>s@@rr@r@s//rr@c^a]tRt^toRtRtRt]R4t]R4t ]R4t Rt Vt 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\VP: R24h)z{ Classes representing constants containers are not intended to be instantiated. The class object itself is used directly. z may not be instantiated.) TypeErrorr)rNs&rrD_ConstantsContainer.__new__sGHHrc \#)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)rNrrQs&&&rrJ$_ConstantsContainer._constantFactorys rc NWP9d \W4#\V4h)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}. )rKrErG)rNrs&&r lookupByName _ConstantsContainer.lookupByNames$ ?? "3% %rc dVPP4p\\VRR74#)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. cVP#r )r)rQs&r3_ConstantsContainer.iterconstants..s Z5F5Fr)key)rKvaluesiterrI)rNrPs& r iterconstants!_ConstantsContainer.iterconstantss0OO**,  9"F GI IrrV) rr7r8r9r:rBrD classmethodrJrarjr;r<r=s@rrYrYsU MI  $ I IrrYc]tRtRtRtRtR#) NamedConstantia 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. rVN)rr7r8r9r:r;rVrrrorosrroc]tRtRtRt]tRtR#)NamesizY A L{Names} subclass contains constants which differ only in their names and identities. rVN)rr7r8r9r:rorBr;rVrrrqrqs"Mrrqc*a]tRtRtoRtRtRtVtR#) 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<\PV4WnR#r r rr4rr4s&&rrValueConstant.__init__04  r)r4N)rr7r8r9r:rr;r<r=s@rrsrs(srrsc8a]tRtRtoRt]t]R4tRt Vt R#)Valuesi6zU A L{Values} subclass contains constants which are associated with arbitrary values. c pVP4FpVPV8XgKVu# \V4h)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}. )rjr4rG)rNr4constants&& r lookupByValueValues.lookupByValue=s5))+H~~&,rrVN) rr7r8r9r:rsrBrlr}r;r<r=s@rrzrz6s#"M  rrzcV!VPVP4pV!VPVP4p\4pVPVPWC4V#)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. )r4names FlagConstantr5r )opleftrightr4rresults&&& r_flagOprQsJ tzz5;; 'E tzz5;; 'E ^F OODOOU2 Mrcda]tRtRtoRt]3RltRtRtRt Rt Rt R t R t R t]tR tVtR #)rifa 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<\PV4WnR#r rurvs&&rrFlagConstant.__init__nrxrc \V\4'dTp\V.4pM=\V4^8XdVwpM(RRP \ V44,R,p\ PWWC4W0nW 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 strsetlenjoinrIr r5r4r)rr3rr4rs&&&& rr5FlagConstant._realizessi$ eS ! !DLE Z1_GT&-0036D4D8  rc "\\W4#)z Define C{|} on two L{FlagConstant} instances to create a new L{FlagConstant} instance with all flags set in either instance set. )rrr#s&&r__or__FlagConstant.__or__s sD((rc "\\W4#)z Define C{&} on two L{FlagConstant} instances to create a new L{FlagConstant} instance with only flags set in both instances set. )rrr#s&&r__and__FlagConstant.__and__s tT))rc "\\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. )rrr#s&&r__xor__FlagConstant.__xor__s sD((rc \4pVPVP\4^4VPP 4F/pVP VP ,^8XgK'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. )rr5r rrjr4)rrflags& r __invert__FlagConstant.__invert__s[ 2OO113DzzDJJ&!+4 rc 0aV3RlSP4#)z9 @return: An iterator of flags set on this instance set. c3Z<"TF pSPPV4xK" R#5ir )r ra).0rrs& r (FlagConstant.__iter__..s#Jzt,,T22zs(+)rrsfr__iter__FlagConstant.__iter__sKtzzJJrc $\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)rrs&&r __contains__FlagConstant.__contains__sDK  rc ,\VP4#)z< @return: C{False} if this flag's value is 0, else C{True}. )rr4rs&r __nonzero__FlagConstant.__nonzero__sDJJr)rr4N)rr7r8r9r:r^rr5rrrrrrr__bool__r;r<r=s@rrrfsD* <)*) K ! Hrrc<a]tRtRtoRt]t^t]R4t Rt Vt R#)Flagsiz 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\Jd(VPpV;P^,unV#VPpV^,VnV#)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}. )r4r^_value)rNrrQr4s&&& rrJFlags._constantFactorysM   | +JJE JJ1 J $$E!CJ rrVN) rr7r8r9r:rrBrrlrJr;r<r=s@rrrs( !M FrrN)r: __future__rr__all__ functoolsr itertoolsroperatorrrrobjectr^nextrr typer@rYrorqrsrzrrrrVrrrs  1 ##x uw'mmb4d4~II1"viDIIZI" " I   6*i9iZFr