U ?fÉUÚ>ã@sdZddlmZmZddddddgZdd lmZdd lmZdd l m Z m Z m Z e ƒZeeeƒƒZGd d „d e ƒZGdd„deƒZGdd„dede fiƒƒZGdd„deƒZGdd„deƒZGdd„deƒZGdd„deƒZdd„ZGdd„deƒZGdd„deƒZdS)zi Symbolic constant support, including collections and constants with text, numeric, and bit flag values. é)ÚdivisionÚabsolute_importÚ NamedConstantÚ ValueConstantÚ FlagConstantÚNamesÚValuesÚFlags)Úpartial)Úcount)Úand_Úor_Úxorc@sHeZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dS)Ú _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. cCsd|_tƒ|_dS©N)Ú _containerÚ_constantOrderÚ_index©Úself©rú7/usr/lib/python3/dist-packages/constantly/_constants.pyÚ__init__#sz_Constant.__init__cCsd|jj|jfS)zq Return text identifying both which constant this is and which collection it belongs to. z<%s=%s>)rÚ__name__ÚnamerrrrÚ__repr__(sz_Constant.__repr__cCs(t||jƒr|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__rÚNotImplementedr©rÚotherrrrÚ__lt__0s ÿ þz_Constant.__lt__cCs0t||jƒr|j|jkstS||kp.|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 rrrÚ__le__Bs ÿ þz_Constant.__le__cCs(t||jƒr|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 rrrÚ__gt__Ts ÿ þz_Constant.__gt__cCs0t||jƒr|j|jkstS||kp.|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 rrrÚ__ge__fs ÿ þz_Constant.__ge__cCs||_||_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Ú containerrÚvaluerrrÚ_realizexs z_Constant._realizeN) rÚ __module__Ú __qualname__Ú__doc__rrr"r#r$r%r(rrrrrs rcs eZdZdZ‡fdd„Z‡ZS)Ú_ConstantsContainerTypeza L{_ConstantsContainerType} is a metaclass for creating constants container classes. c sÂtt|ƒ ||||¡}t|ddƒ}|dkr.|Sg}| ¡D]B\}}t||jƒr:|jdk rjtd||j fƒ‚|  |j ||f¡q:i}t |ƒD],\} } }|  | |¡} | || | ¡||| <qŠ||_|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} Ú _constantTypeNz0Cannot use %s as the value of an attribute on %s)Úsuperr,Ú__new__ÚgetattrÚitemsrr-rÚ ValueErrorrÚappendrÚsortedÚ_constantFactoryr(Ú _enumerants) rrÚbasesZ attributesÚclsZ constantTypeÚ constantsÚ descriptorZ enumerantsÚindexZ enumerantr'©rrrr/Žs6 ÿ   ÿÿ  z_ConstantsContainerType.__new__)rr)r*r+r/Ú __classcell__rrr<rr,‰sr,c@s@eZdZdZdZdd„Zedd„ƒZedd„ƒZed d „ƒZ 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. NcCstd|jfƒ‚dS)z› Classes representing constants containers are not intended to be instantiated. The class object itself is used directly. z%s may not be instantiated.N)Ú TypeErrorr)r8rrrr/Øsz_ConstantsContainer.__new__cCstS)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)r8rr:rrrr5âs z$_ConstantsContainer._constantFactorycCs ||jkrt||ƒSt|ƒ‚dS)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}. N)r6r0r2)r8rrrrÚ lookupByNameòs  z _ConstantsContainer.lookupByNamecCs|j ¡}tt|dd„dƒS)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. cSs|jSr)r)r:rrrÚóz3_ConstantsContainer.iterconstants..)Úkey)r6ÚvaluesÚiterr4)r8r9rrrÚ iterconstantss ÿz!_ConstantsContainer.iterconstants) rr)r*r+r-r/Ú classmethodr5rArGrrrrr>Ès    r>Úc@seZdZdZdS)ra 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)rr)r*r+rrrrrsc@seZdZdZeZdS)rze A L{Names} subclass contains constants which differ only in their names and identities. N)rr)r*r+rr-rrrrr!sc@seZdZdZdd„ZdS)ra 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. cCst |¡||_dSr©rrr'©rr'rrrr2s zValueConstant.__init__N)rr)r*r+rrrrrr*sc@s eZdZdZeZedd„ƒZdS)rza A L{Values} subclass contains constants which are associated with arbitrary values. cCs,| ¡D]}|j|kr|Sqt|ƒ‚dS)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}. N)rGr'r2)r8r'ZconstantrrrÚ lookupByValue?s   zValues.lookupByValueN)rr)r*r+rr-rHrLrrrrr8scCs6||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'Únamesrr(r)ÚopÚleftÚrightr'rMÚresultrrrÚ_flagOpSs rRc@s`eZdZdZefdd„Zdd„Zdd„Zdd „Zd d „Z d d „Z dd„Z dd„Z dd„Z e ZdS)ra 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. cCst |¡||_dSrrJrKrrrrps zFlagConstant.__init__cCsdt|tƒr|}t|gƒ}n*t|ƒdkr.|\}ndd t|ƒ¡d}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) rÚstrÚsetÚlenÚjoinr4rr(r'rM)rr&rMr'rrrrr(us   zFlagConstant._realizecCs 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. )rRr r rrrÚ__or__“szFlagConstant.__or__cCs 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. )rRr r rrrÚ__and__›szFlagConstant.__and__cCs 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. )rRrr rrrÚ__xor__£szFlagConstant.__xor__cCsDtƒ}| |jtƒd¡|j ¡D]}|j|j@dkr"||O}q"|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)rr(rrXrGr')rrQÚflagrrrÚ __invert__¬s  zFlagConstant.__invert__cs‡fdd„ˆjDƒS)zI @return: An iterator of flags set on this instance set. c3s|]}ˆj |¡VqdSr)rrA)Ú.0rrrrÚ ½sz(FlagConstant.__iter__..)rMrrrrÚ__iter__¹szFlagConstant.__iter__cCs t||@ƒS)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)rr^rrrÚ __contains__Às zFlagConstant.__contains__cCs t|jƒS)zL @return: C{False} if this flag's value is 0, else C{True}. )rcr'rrrrÚ __nonzero__ÌszFlagConstant.__nonzero__N)rr)r*r+r@rr(r[r\r]r_rbrdreÚ__bool__rrrrrhs    c@s$eZdZdZeZdZedd„ƒZdS)r 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. rScCs4|jtkr |j}|jdK_n|j}|d>|_|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}. rS)r'r@Ú_value)r8rr:r'rrrr5ßs   zFlags._constantFactoryN) rr)r*r+rr-rgrHr5rrrrr Õs N)r+Z __future__rrÚ__all__Ú functoolsr Ú itertoolsr Úoperatorr r rÚobjectr@ÚnextrrÚtyper,r>rrrrrRrr rrrrÚs.þ   q?M  m