← Back
Editing: _constants.cpython-38.pyc
U ?f�U�> � @ s d Z ddlmZmZ ddddddgZdd lmZ dd lmZ dd l m Z m Z m Z e � Zeee� �ZG d d � d e �ZG dd� de�ZG dd� dede fi ��ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�Zdd� ZG dd� de�ZG dd� 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 @ sH e Zd ZdZdd� 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. c C s d | _ t� | _d S �N)� _container�_constantOrder�_index��self� r �7/usr/lib/python3/dist-packages/constantly/_constants.py�__init__# s z_Constant.__init__c C s d| j j| jf S )zq Return text identifying both which constant this is and which collection it belongs to. z<%s=%s>)r �__name__�namer r r r �__repr__( s z_Constant.__repr__c C s( t || j�r| j|jks tS | j|jk S )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 �otherr r r �__lt__0 s � �z_Constant.__lt__c C s0 t || j�r| j|jks tS | |kp.| j|jk S )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}. r r r r r �__le__B s � �z_Constant.__le__c C s( t || j�r| j|jks tS | 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}. r r r r r �__gt__T s � �z_Constant.__gt__c C s0 t || j�r| j|jks tS | |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}. r r r r r �__ge__f s � �z_Constant.__ge__c C s || _ || _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 � containerr �valuer r r �_realizex s z_Constant._realizeN) r � __module__� __qualname__�__doc__r r r" r# r$ r% r( r r r r r s r c s e Zd ZdZ� fdd�Z� ZS )�_ConstantsContainerTypeza L{_ConstantsContainerType} is a metaclass for creating constants container classes. c s� t t| ��| |||�}t|dd�}|dkr.|S g }|�� 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�itemsr r- r � ValueErrorr �appendr �sorted�_constantFactoryr( � _enumerants) r r �basesZ attributes�clsZ constantType� constants� descriptorZ enumerants�indexZ enumerantr' �r r r r/ � s6 � �� z _ConstantsContainerType.__new__)r r) r* r+ r/ � __classcell__r r r< r r, � s r, c @ s@ e Zd ZdZdZdd� 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. Nc C s t d| 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 )r8 r r r r/ � s z_ConstantsContainer.__new__c C s t S )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)r8 r r: r r r r5 � s z$_ConstantsContainer._constantFactoryc C s || j krt| |�S t|��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)r6 r0 r2 )r8 r r r r � lookupByName� s z _ConstantsContainer.lookupByNamec C s | 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. c S s | j S r )r )r: r r r �<lambda> � z3_ConstantsContainer.iterconstants.<locals>.<lambda>)�key)r6 �values�iterr4 )r8 r9 r r r � iterconstants s �z!_ConstantsContainer.iterconstants) r r) r* r+ r- r/ � classmethodr5 rA rG r r r r r> � s r> � c @ s e Zd ZdZdS )r a 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)r r) r* r+ r r r r r s c @ s e Zd ZdZeZdS )r ze A L{Names} subclass contains constants which differ only in their names and identities. N)r r) r* r+ r r- r r r r r ! s c @ s e Zd ZdZdd� ZdS )r 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 C s t �| � || _d S r �r r r' �r r' r r r r 2 s zValueConstant.__init__N)r r) r* r+ r r r r r r * s c @ s e Zd ZdZeZedd� �ZdS )r za A L{Values} subclass contains constants which are associated with arbitrary values. c C s, | � � D ]}|j|kr| S qt|��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)rG r' r2 )r8 r' Zconstantr r r � lookupByValue? s zValues.lookupByValueN)r r) r* r+ r r- rH rL r r r r r 8 s c C s6 | |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' �namesr r( r )�op�left�rightr' rM �resultr r r �_flagOpS s rR c @ s` e Zd ZdZefdd�Zdd� Zdd� Zdd � Zd d � Z d d � Z dd� Z dd� Z dd� Z e ZdS )r a 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 C s t �| � || _d S r rJ rK r r r r p s zFlagConstant.__init__c C sd t |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�joinr4 r r( r' rM )r r& rM r' r r r r r( u s zFlagConstant._realizec C s t t| |�S )z� Define C{|} on two L{FlagConstant} instances to create a new L{FlagConstant} instance with all flags set in either instance set. )rR r r r r r �__or__� s zFlagConstant.__or__c C s t t| |�S )z� Define C{&} on two L{FlagConstant} instances to create a new L{FlagConstant} instance with only flags set in both instances set. )rR r r r r r �__and__� s zFlagConstant.__and__c C s t t| |�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. )rR r r r r r �__xor__� s zFlagConstant.__xor__c C sD t � }|�| 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 )r r( r rX rG r' )r rQ �flagr r r � __invert__� s zFlagConstant.__invert__c s � fdd�� j D �S )zI @return: An iterator of flags set on this instance set. c 3 s | ]}� j �|�V qd S r )r rA )�.0r r r r � <genexpr>� s z(FlagConstant.__iter__.<locals>.<genexpr>)rM r r r r �__iter__� s zFlagConstant.__iter__c C s 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)r r^ r r r � __contains__� s zFlagConstant.__contains__c C s t | j�S )zL @return: C{False} if this flag's value is 0, else C{True}. )rc r' r r r r � __nonzero__� s zFlagConstant.__nonzero__N)r r) r* r+ r@ r r( r[ r\ r] r_ rb rd re �__bool__r r r r r h s c @ s$ e Zd ZdZeZdZedd� �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. rS c C s4 |j tkr | 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)r8 r r: r' r r r r5 � s zFlags._constantFactoryN) r r) r* r+ r r- rg rH r5 r r r r r � s N) r+ Z __future__r r �__all__� functoolsr � itertoolsr �operatorr r r �objectr@ �nextr r �typer, r> r r r r rR r r r r r r �<module> s. � q?M m
Save File
Cancel