o >h>@sdZddlmZmZgZddlmZddlmZddl m Z m Z m Z e ZeeeZGddde ZGdd d eZGd d d ed e fiZGd ddeZGdddeZGdddeZGdddeZddZGdddeZGdddeZdS)zi Symbolic constant support, including collections and constants with text, numeric, and bit flag values. )divisionabsolute_import)partial)count)and_or_xorc@sHeZdZdZddZddZddZdd Zd d Zd d Z ddZ 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|_dSN) _container_constantOrder_indexselfru/var/www/vedio/testing/chatpythonscript.ninositsolution.com/env/lib/python3.10/site-packages/constantly/_constants.py__init__!s z_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||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__r NotImplementedr rotherrrr__lt__.   z_Constant.__lt__cCs0t||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}. rrrrr__le__@  z_Constant.__le__cCs(t||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}. rrrrr__gt__Rrz_Constant.__gt__cCs0t||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}. rrrrr__ge__drz_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)r r)r containerrvaluerrr_realizevs z_Constant._realizeN) r __module__ __qualname____doc__rrrrr r!r$rrrrr s  r cs eZdZdZfddZZS)_ConstantsContainerTypeza L{_ConstantsContainerType} is a metaclass for creating constants container classes. c stt|||||}t|dd}|dur|Sg}|D]!\}}t||jr>|jdur5td||j f| |j ||fqi}t |D]\} } }| | |} ||| | ||| <qE||_|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__getattritemsrr)r ValueErrorrappendr sorted_constantFactoryr$ _enumerants) rrbases attributescls constantType constants descriptor enumerantsindex enumerantr#rrrr+s0      z_ConstantsContainerType.__new__)rr%r&r'r+ __classcell__rrr<rr(sr(c@s@eZdZdZdZddZeddZeddZed 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)z Classes representing constants containers are not intended to be instantiated. The class object itself is used directly. z%s may not be instantiated.) TypeErrorr)r5rrrr+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)r5rr8rrrr1s z$_ConstantsContainer._constantFactorycCs||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}. )r2r,r.)r5rrrr lookupByNames  z _ConstantsContainer.lookupByNamecCs|j}tt|dddS)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 )r8rrrsz3_ConstantsContainer.iterconstants..)key)r2valuesiterr0)r5r7rrr iterconstantss z!_ConstantsContainer.iterconstants) rr%r&r'r)r+ classmethodr1rArFrrrrr>s   r>c@seZdZdZdS) 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)rr%r&r'rrrrrIsrIc@seZdZdZeZdS)Namesze A L{Names} subclass contains constants which differ only in their names and identities. N)rr%r&r'rIr)rrrrrJsrJc@seZdZdZddZdS) 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. cCt|||_dSr r rr#rr#rrrr0  zValueConstant.__init__N)rr%r&r'rrrrrrK(s rKc@s eZdZdZeZeddZdS)Valuesza A L{Values} subclass contains constants which are associated with arbitrary values. cCs(|D] }|j|kr|Sqt|)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}. )rFr#r.)r5r#constantrrr lookupByValue=s zValues.lookupByValueN)rr%r&r'rKr)rGrRrrrrrP6s rPcCs6||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 FlagConstantr$r )opleftrightr#rSresultrrr_flagOpQs  rYc@s`eZdZdZefddZddZddZdd Zd d Z d d Z ddZ ddZ ddZ e ZdS)rTa 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. cCrLr rMrNrrrrnrOzFlagConstant.__init__cCsdt|tr |}t|g}nt|dkr|\}n ddt|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) rstrsetlenjoinr0r r$r#rS)rr"rSr#rrrrr$ss    zFlagConstant._realizecC 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. )rYrrrrr__or__ zFlagConstant.__or__cCrb)z Define C{&} on two L{FlagConstant} instances to create a new L{FlagConstant} instance with only flags set in both instances set. )rYrrrrr__and__rdzFlagConstant.__and__cCrb)z Define C{^} on two L{FlagConstant} instances to create a new L{FlagConstant} instance with only flags set on exactly one instance set. )rYrrrrr__xor__s zFlagConstant.__xor__cCsDt}||jtd|jD]}|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)rTr$r r_rFr#)rrXflagrrr __invert__szFlagConstant.__invert__csfddjDS)zI @return: An iterator of flags set on this instance set. c3s|] }j|VqdSr )r rA).0rrrr sz(FlagConstant.__iter__..)rSrrrr__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)rrgrrr __contains__s zFlagConstant.__contains__cCs t|jS)zL @return: C{False} if this flag's value is 0, else C{True}. )rlr#rrrr __nonzero__s zFlagConstant.__nonzero__N)rr%r&r'r@rr$rcrerfrhrkrmrn__bool__rrrrrTfs    rTc@s$eZdZdZeZdZeddZdS)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. rZcCs6|jtur|j}|jdK_|S|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}. rZ)r#r@_value)r5rr8r#rrrr1s  zFlags._constantFactoryN) rr%r&r'rTr)rqrGr1rrrrrps rpN)r' __future__rr__all__ functoolsr itertoolsroperatorrrrobjectr@nextr r typer(r>rIrJrKrPrYrTrprrrrs$   q?M  m