File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/constantly.tar
Back
__pycache__/__init__.cpython-310.pyc 0000644 00000001073 15030213225 0013206 0 ustar 00 o ?f�U � @ sV d dl mZmZmZmZmZmZ ddlmZ e� d Z [dZ dZ d� e �Z g d�Zd S ) � )� NamedConstant�Names� ValueConstant�Values� FlagConstant�Flags� )� get_versions�versionzTwisted Matrix Laboratories�MITzCopyright 2011-2015 {0})r r r r r r N)�constantly._constantsr r r r r r �_versionr � __version__� __author__� __license__�format� __copyright__�__all__� r r �5/usr/lib/python3/dist-packages/constantly/__init__.py�<module> s __pycache__/_constants.cpython-310.pyc 0000644 00000037755 15030213225 0013642 0 ustar 00 o ?f�U�> � @ s d Z ddlmZmZ g d�ZddlmZ ddlmZ ddl m Z m Z m Z e � Zeee� �ZG dd� de �ZG d d � d e�ZG d d � d ed e fi ��ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�Zdd� ZG dd� de�ZG dd� de�Zd S ) 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|jkstS | 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 � � z_Constant.__lt__c C s0 t || j�r | j|jkstS | |u p| 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 � � z_Constant.__le__c C s( 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}. r r r r r �__gt__T r# z_Constant.__gt__c C s0 t || j�r | j|jkstS | |u p| 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 r% 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�}|du r|S g }|�� D ]!\}}t||j�r>|jdur5td||j f ��|� |j ||f� q i }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__�getattr�itemsr r/ r � ValueErrorr �appendr �sorted�_constantFactoryr* � _enumerants) r r �bases� attributes�cls� constantType� constants� descriptor� enumerants�index� enumerantr) �r r r r1 � s0 � ��� z _ConstantsContainerType.__new__)r r+ r, r- r1 � __classcell__r r rB 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 ��)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 )r; r r r r1 � 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)r; r r> r r r r7 � s z$_ConstantsContainer._constantFactoryc C s || j v r t| |�S t|��)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}. )r8 r2 r4 )r; 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> s z3_ConstantsContainer.iterconstants.<locals>.<lambda>)�key)r8 �values�iterr6 )r; r= r r r � iterconstants s �z!_ConstantsContainer.iterconstants) r r+ r, r- r/ r1 � classmethodr7 rG rL r r r r rD � s rD � 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 r 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 r 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 � t �| � || _d S r �r r r) �r r) r r r r 2 � zValueConstant.__init__N)r r+ r, r- r r r r r r * s r 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|��)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}. )rL r) r4 )r; r) �constantr r r � lookupByValue? s �zValues.lookupByValueN)r r+ r, r- r r/ rM rT r r r r r 8 s r 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) rU �resultr r r �_flagOpS s rZ 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 rO r rP rQ r r r r p rR zFlagConstant.__init__c C sd t |t�r |}t|g�}nt|�dkr|\}n dd�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�joinr6 r r* r) rU )r r( rU r) r r r r r* u s zFlagConstant._realizec C � 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. )rZ r r r r r �__or__� � zFlagConstant.__or__c C rc )z� Define C{&} on two L{FlagConstant} instances to create a new L{FlagConstant} instance with only flags set in both instances set. )rZ r r r r r �__and__� re zFlagConstant.__and__c C rc )z� Define C{^} on two L{FlagConstant} instances to create a new L{FlagConstant} instance with only flags set on exactly one instance set. )rZ 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 r` rL r) )r rY �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 rG )�.0r r r r � <genexpr>� s � z(FlagConstant.__iter__.<locals>.<genexpr>)rU 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 rh 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}. )rm r) r r r r � __nonzero__� s zFlagConstant.__nonzero__N)r r+ r, r- rF r r* rd rf rg ri rl rn ro �__bool__r r r r r h s r 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. r[ c C s6 |j tu r| 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}. r[ )r) rF �_value)r; r r> r) r r r r7 � s � zFlags._constantFactoryN) r r+ r, r- r r/ rq rM r7 r r r r r � s r N) r- � __future__r r �__all__� functoolsr � itertoolsr �operatorr r r �objectrF �nextr r �typer. rD r r r r rZ r r r r r r �<module> s$ q?M m __pycache__/_version.cpython-310.pyc 0000644 00000000701 15030213225 0013270 0 ustar 00 o 4]�^� � @ s d dl Z d dlZdZdd� ZdS )� Nz{ { "dirty": false, "error": null, "full-revisionid": "c8375a7e3431792ea1b1b44678f3f6878d5e8c9a", "version": "15.1.0" } c C s t �t�S )N)�json�loads� version_json� r r �5/usr/lib/python3/dist-packages/constantly/_version.py� get_versions s r )r �sysr r r r r r �<module> s _constants.py 0000644 00000037332 15030213225 0007272 0 ustar 00 # -*- test-case-name: constantly.test.test_constants -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Symbolic constant support, including collections and constants with text, numeric, and bit flag values. """ from __future__ import division, absolute_import __all__ = [ 'NamedConstant', 'ValueConstant', 'FlagConstant', 'Names', 'Values', 'Flags'] from functools import partial from itertools import count from operator import and_, or_, xor _unspecified = object() _constantOrder = partial(next, count()) class _Constant(object): """ @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. """ def __init__(self): self._container = None self._index = _constantOrder() def __repr__(self): """ Return text identifying both which constant this is and which collection it belongs to. """ return "<%s=%s>" % (self._container.__name__, self.name) def __lt__(self, other): """ 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}. """ if ( not isinstance(other, self.__class__) or not self._container == other._container ): return NotImplemented return self._index < other._index def __le__(self, other): """ 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}. """ if ( not isinstance(other, self.__class__) or not self._container == other._container ): return NotImplemented return self is other or self._index < other._index def __gt__(self, other): """ 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}. """ if ( not isinstance(other, self.__class__) or not self._container == other._container ): return NotImplemented return self._index > other._index def __ge__(self, other): """ 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}. """ if ( not isinstance(other, self.__class__) or not self._container == other._container ): return NotImplemented return self is other or self._index > other._index def _realize(self, container, name, value): """ 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. """ self._container = container self.name = name class _ConstantsContainerType(type): """ L{_ConstantsContainerType} is a metaclass for creating constants container classes. """ def __new__(self, name, bases, attributes): """ 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} """ cls = super(_ConstantsContainerType, self).__new__( self, name, bases, attributes) # Only realize constants in concrete _ConstantsContainer subclasses. # Ignore intermediate base classes. constantType = getattr(cls, '_constantType', None) if constantType is None: return cls constants = [] for (name, descriptor) in attributes.items(): if isinstance(descriptor, cls._constantType): if descriptor._container is not None: raise ValueError( "Cannot use %s as the value of an attribute on %s" % ( descriptor, cls.__name__)) constants.append((descriptor._index, name, descriptor)) enumerants = {} for (index, enumerant, descriptor) in sorted(constants): value = cls._constantFactory(enumerant, descriptor) descriptor._realize(cls, enumerant, value) enumerants[enumerant] = descriptor # Save the dictionary which contains *only* constants (distinct from # any other attributes the application may have given the container) # where the class can use it later (eg for lookupByName). cls._enumerants = enumerants return cls # In Python3 metaclasses are defined using a C{metaclass} keyword argument in # the class definition. This would cause a syntax error in Python2. # So we use L{type} to introduce an intermediate base class with the desired # metaclass. # See: # * http://docs.python.org/2/library/functions.html#type # * http://docs.python.org/3/reference/datamodel.html#customizing-class-creation class _ConstantsContainer(_ConstantsContainerType('', (object,), {})): """ 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. """ _constantType = None def __new__(cls): """ Classes representing constants containers are not intended to be instantiated. The class object itself is used directly. """ raise TypeError("%s may not be instantiated." % (cls.__name__,)) @classmethod def _constantFactory(cls, name, descriptor): """ 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. """ return _unspecified @classmethod def lookupByName(cls, name): """ 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}. """ if name in cls._enumerants: return getattr(cls, name) raise ValueError(name) @classmethod def iterconstants(cls): """ 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. """ constants = cls._enumerants.values() return iter( sorted(constants, key=lambda descriptor: descriptor._index)) class NamedConstant(_Constant): """ 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. """ class Names(_ConstantsContainer): """ A L{Names} subclass contains constants which differ only in their names and identities. """ _constantType = NamedConstant class ValueConstant(_Constant): """ 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. """ def __init__(self, value): _Constant.__init__(self) self.value = value class Values(_ConstantsContainer): """ A L{Values} subclass contains constants which are associated with arbitrary values. """ _constantType = ValueConstant @classmethod def lookupByValue(cls, value): """ 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}. """ for constant in cls.iterconstants(): if constant.value == value: return constant raise ValueError(value) def _flagOp(op, left, right): """ 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. """ value = op(left.value, right.value) names = op(left.names, right.names) result = FlagConstant() result._realize(left._container, names, value) return result class FlagConstant(_Constant): """ 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. """ def __init__(self, value=_unspecified): _Constant.__init__(self) self.value = value def _realize(self, container, names, value): """ 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. """ if isinstance(names, str): name = names names = set([names]) elif len(names) == 1: (name,) = names else: name = "{" + ",".join(sorted(names)) + "}" _Constant._realize(self, container, name, value) self.value = value self.names = names def __or__(self, other): """ Define C{|} on two L{FlagConstant} instances to create a new L{FlagConstant} instance with all flags set in either instance set. """ return _flagOp(or_, self, other) def __and__(self, other): """ Define C{&} on two L{FlagConstant} instances to create a new L{FlagConstant} instance with only flags set in both instances set. """ return _flagOp(and_, self, other) def __xor__(self, other): """ Define C{^} on two L{FlagConstant} instances to create a new L{FlagConstant} instance with only flags set on exactly one instance set. """ return _flagOp(xor, self, other) def __invert__(self): """ Define C{~} on a L{FlagConstant} instance to create a new L{FlagConstant} instance with all flags not set on this instance set. """ result = FlagConstant() result._realize(self._container, set(), 0) for flag in self._container.iterconstants(): if flag.value & self.value == 0: result |= flag return result def __iter__(self): """ @return: An iterator of flags set on this instance set. """ return (self._container.lookupByName(name) for name in self.names) def __contains__(self, flag): """ @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}. """ # Optimization for testing membership without iteration. return bool(flag & self) def __nonzero__(self): """ @return: C{False} if this flag's value is 0, else C{True}. """ return bool(self.value) __bool__ = __nonzero__ class Flags(Values): """ 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. """ _constantType = FlagConstant _value = 1 @classmethod def _constantFactory(cls, name, descriptor): """ 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}. """ if descriptor.value is _unspecified: value = cls._value cls._value <<= 1 else: value = descriptor.value cls._value = value << 1 return value _version.py 0000644 00000000730 15030213225 0006733 0 ustar 00 # This file was generated by 'versioneer.py' (0.15) from # revision-control system data, or from the parent directory name of an # unpacked source archive. Distribution tarballs contain a pre-generated copy # of this file. import json import sys version_json = ''' { "dirty": false, "error": null, "full-revisionid": "c8375a7e3431792ea1b1b44678f3f6878d5e8c9a", "version": "15.1.0" } ''' # END VERSION_JSON def get_versions(): return json.loads(version_json) __init__.py 0000644 00000001005 15030213225 0006642 0 ustar 00 # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. from constantly._constants import ( NamedConstant, Names, ValueConstant, Values, FlagConstant, Flags ) from ._version import get_versions __version__ = get_versions()['version'] del get_versions __author__ = "Twisted Matrix Laboratories" __license__ = "MIT" __copyright__ = "Copyright 2011-2015 {0}".format(__author__) __all__ = [ 'NamedConstant', 'ValueConstant', 'FlagConstant', 'Names', 'Values', 'Flags', ]
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings