͛h> PSrSSKJrJr /rSSKJr SSKJr SSK J r J r J r \ "5r\"\\"55r"SS\ 5r"SS \5r"S S \"S \ 4055r"S S\5r"SS\5r"SS\5r"SS\5rSr"SS\5r"SS\5rg)zi Symbolic constant support, including collections and constants with text, numeric, and bit flag values. )divisionabsolute_import)partial)count)and_or_xorcB\rSrSrSrSrSrSrSrSr Sr S r S r g ) _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. c0SUl[5UlgN) _container_constantOrder_indexselfs YC:\Users\psant\Downloads\Noiseback\school\venv\Lib\site-packages\constantly/_constants.py__init___Constant.__init__!s$& cTSURR<SUR<S3$)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[XR5(aURUR:Xd[$URUR:$)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__rNotImplementedrrothers r__lt___Constant.__lt__.>5..115#3#33! !{{U\\))rc[XR5(aURUR:Xd[$XL=(d URUR:$)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__@E5..115#3#33! !}: ell ::rc[XR5(aURUR:Xd[$URUR:$)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__Rr)rc[XR5(aURUR:Xd[$XL=(d URUR:$)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__dr-rcXlX lg)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)rr)r containerrvalues r_realize_Constant._realizevs$ r)rrrN) r __module__ __qualname____firstlineno____doc__rrr'r+r/r2r7__static_attributes__rrr r s+ ' A*$;$*$;$ rr c,^\rSrSrSrU4SjrSrU=r$)_ConstantsContainerTypezU L{_ConstantsContainerType} is a metaclass for creating constants container classes. c>[[U] XX#5n[USS5nUcU$/nUR 5Hhup[ XtR 5(dM!URb[SU<SUR<35eURURX45 Mj 0n[U5H-upnURX5n URXJU 5 XxU 'M/ XlU$)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"rCr ValueErrorrappendrsorted_constantFactoryr7 _enumerants) rrbases attributescls constantType constants descriptor enumerantsindex enumerantr6r#s rrE_ConstantsContainerType.__new__s$+T: + sOT:  J ","2"2"4 T*&7&788((4$& 677  *"3"3T!FG #5 .4Y.? *Uz((?E    6$.y !/@% rr>)rr9r:r;r<rEr= __classcell__)r#s@rr@r@s//rr@cR\rSrSrSrSrSr\S5r\S5r \S5r Sr g) _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. Nc4[UR<S35e)z{ Classes representing constants containers are not intended to be instantiated. The class object itself is used directly. z may not be instantiated.) TypeErrorr)rOs rrE_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)rOrrRs rrK$_ConstantsContainer._constantFactorys rcLXR;a [X5$[U5e)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}. )rLrFrH)rOrs r lookupByName _ConstantsContainer.lookupByNames$ ?? "3% %rc^URR5n[[USS95$)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. cUR$r)r)rRs r3_ConstantsContainer.iterconstants..s Z5F5Fr)key)rLvaluesiterrJ)rOrQs r iterconstants!_ConstantsContainer.iterconstantss0OO**,  9"F GI Irr>) rr9r:r;r<rCrE classmethodrKrbrkr=r>rrrYrYsR MI  $ I IrrYc\rSrSrSrSrg) 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. r>N)rr9r:r;r<r=r>rrrprpsrrpc\rSrSrSr\rSrg)NamesizY A L{Names} subclass contains constants which differ only in their names and identities. r>N)rr9r:r;r<rprCr=r>rrrrrrs"Mrrrc\rSrSrSrSrSrg) 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:[RU5 Xlgrr rr6rr6s rrValueConstant.__init__04  r)r6N)rr9r:r;r<rr=r>rrrtrt(s rrtc,\rSrSrSr\r\S5rSr g)Valuesi6zU A L{Values} subclass contains constants which are associated with arbitrary values. cnUR5HnURU:XdMUs $ [U5e)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}. )rkr6rH)rOr6constants r lookupByValueValues.lookupByValue=s5))+H~~&,rr>N) rr9r:r;r<rtrCrmr~r=r>rrr{r{6s "M  rr{cU"URUR5nU"URUR5n[5nURURXC5 U$)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. )r6names FlagConstantr7r)opleftrightr6rresults r_flagOprQsJ tzz5;; 'E tzz5;; 'E ^F OODOOU2 MrcX\rSrSrSr\4SjrSrSrSr Sr Sr S r S r S r\rS rg )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:[RU5 Xlgrrvrws rrFlagConstant.__init__nryrc[U[5(aUn[U/5nO4[U5S:XaUunO SSR [ U55-S-n[ RXXC5 X0lX l g)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"strsetlenjoinrJr r7r6r)rr5rr6rs rr7FlagConstant._realizessi$ eS ! !DLE Z1_GT&-0036D4D8  rc"[[X5$)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"[[X5$)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"[[X5$)z Define C{^} on two L{FlagConstant} instances to create a new L{FlagConstant} instance with only flags set on exactly one instance set. )rr r%s r__xor__FlagConstant.__xor__s sD((rc[5nURUR[5S5 URR 5H&nUR UR -S:XdM"X-nM( U$)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)rr7rrrkr6)rrflags r __invert__FlagConstant.__invert__s[ 2OO113DzzDJJ&!+4 rc0^U4SjTR5$)z9 @return: An iterator of flags set on this instance set. c3Z># UH nTRRU5v M" g7fr)rrb).0rrs r (FlagConstant.__iter__..s#Jzt,,T22zs(+)rrs`r__iter__FlagConstant.__iter__sKtzzJJrc[X-5$)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,[UR5$)z< @return: C{False} if this flag's value is 0, else C{True}. )rr6rs r __nonzero__FlagConstant.__nonzero__sDJJr)rr6N)rr9r:r;r<r_rr7rrrrrrr__bool__r=r>rrrrfsA* <)*) K ! Hrrc0\rSrSrSr\rSr\S5r Sr g)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. rcUR[La#URnU=RS-slU$URnUS-UlU$)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}. r)r6r__value)rOrrRr6s rrKFlags._constantFactorysM   | +JJE JJ1 J $$E!CJ rr>N) rr9r:r;r<rrCrrmrKr=r>rrrrs% !M FrrN)r< __future__rr__all__ functoolsr itertoolsroperatorrrr objectr_nextrr typer@rYrprrrtr{rrrr>rrrs  1 ##x uw'mmb4d4~II1"viDIIZI" " I   6*i9iZFr