?^> PdZddlmZmZgZddlmZddlmZddl m Z m Z m Z e ZeeeZGdde ZGdd eZGd d ed e fiZGd deZGddeZGddeZGddeZdZGddeZGddeZy)zi Symbolic constant support, including collections and constants with text, numeric, and bit flag values. )divisionabsolute_import)partial)count)and_or_xorc:eZdZdZdZdZdZdZdZdZ dZ 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. c0d|_t|_yN) _container_constantOrder_indexselfs 7/usr/lib/python3/dist-packages/constantly/_constants.py__init__z_Constant.__init__!s$& cPd|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 !OO44dii@@rct||jr|j|jk(stS|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$..15#3#33! !{{U\\))rct||jr|j|jk(stS||uxs|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$..15#3#33! !u}: ell ::rct||jr|j|jk(stS|j|jkDS)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|jk(stS||uxs|j|jkDS)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 ||_||_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)rr)r containerrvalues r_realizez_Constant._realizevs$ rN) r __module__ __qualname____doc__rrr$r'r*r,r0rrr r s+ ' A*$;$*$;$ rr c"eZdZdZfdZxZS)_ConstantsContainerTypeza L{_ConstantsContainerType} is a metaclass for creating constants container classes. ctt| ||||}t|dd}||Sg}|j D]a\}}t ||j s|jtd|d|j|j|j||fci}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__getattritemsrr8r ValueErrorrappendrsorted_constantFactoryr0 _enumerants) rrbases attributescls constantType constants descriptor enumerantsindex enumerantr/r s rr:z_ConstantsContainerType.__new__s$+T: $z+ sOT:  J ","2"2"4 H T:*c&7&78((4$& 677  *"3"3T:!FG  H .4Y.? / *UIz((J?E   Y 6$.Jy ! /% r)rr1r2r3r: __classcell__)r s@rr6r6s//rr6cJeZdZdZdZdZedZedZedZ 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. Nc2t|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__sGHHrctS)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 rcL||jvr t||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% %rcd|jj}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 Z5F5Fr)key)rAvaluesiterr?)rDrFs r iterconstantsz!_ConstantsContainer.iterconstantss0OO**,  9"F GI Ir) rr1r2r3r8r: classmethodr@rSrZr4rrrMrMsR MI  $ I IrrMceZdZdZy) 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^ceZdZdZeZy)Namesze A L{Names} subclass contains constants which differ only in their names and identities. N)rr1r2r3r^r8r4rrr`r`s"Mrr`ceZdZdZdZy) 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<tj|||_yr r rr/rr/s rrzValueConstant.__init__04  rN)rr1r2r3rr4rrrbrb(s rrbc$eZdZdZeZedZy)Valuesza A L{Values} subclass contains constants which are associated with arbitrary values. ch|jD]}|j|k(s|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=s:))+ H~~& rN)rr1r2r3rbr8r[rkr4rrrhrh6s "M  rrhc||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 FlagConstantr0r)opleftrightr/rmresults r_flagOprsQsL tzz5;; 'E tzz5;; 'E ^F OODOOUE2 MrcNeZdZdZefdZdZdZdZdZ dZ dZ d Z d Z e Zy ) 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. c<tj|||_yr rdres rrzFlagConstant.__init__nrfrct|tr|}t|g}n3t|dk(r|\}n ddj t |zdz}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) rstrsetlenjoinr?r r0r/rm)rr.rmr/rs rr0zFlagConstant._realizessn$ eS !DLE Z1_GT&-0036D4D%8  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}|j|jtd|jj D]$}|j |j zdk(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)rnr0rr|rZr/)rrrflags r __invert__zFlagConstant.__invert__sb 2OO113 DzzDJJ&!+$  rc.fdjDS)zI @return: An iterator of flags set on this instance set. c3TK|]}jj|!ywr )rrS).0rrs r z(FlagConstant.__iter__..s Jt,,T2Js%()rmrs`r__iter__zFlagConstant.__iter__sKtzzJJrct||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__sDJJrN)rr1r2r3rQrr0rrrrrrr__bool__r4rrrnrnfsA* <)*) K ! Hrrnc(eZdZdZeZdZedZy)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. rwc|jtur#|j}|xjdzc_|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)rDrrGr/s rr@zFlags._constantFactorysM   | +JJE JJ1 J $$E!CJ rN) rr1r2r3rnr8rr[r@r4rrrrs% !M FrrN)r3 __future__rr__all__ functoolsr itertoolsroperatorrrr objectrQnextrr typer6rMr^r`rbrhrsrnrr4rrrs  1 ##x uw'mmb4d4~II1"viDIIZI" " I   6*i9iZFr