[Python-modules-commits] [constantly] 01/02: New upstream version 15.1.0
Free Ekanayaka
freee at moszumanska.debian.org
Fri Nov 4 08:16:14 UTC 2016
This is an automated email from the git hooks/post-receive script.
freee pushed a commit to branch master
in repository constantly.
commit f4ee6c18747c07ca0c65b6d24b19a83a577641e4
Author: Free Ekanayaka <freee at debian.org>
Date: Fri Nov 4 07:39:05 2016 +0000
New upstream version 15.1.0
---
CREDITS | 6 +
LICENSE | 21 +
MANIFEST.in | 5 +
PKG-INFO | 37 +
README.rst | 16 +
constantly.egg-info/PKG-INFO | 37 +
constantly.egg-info/SOURCES.txt | 15 +
constantly.egg-info/dependency_links.txt | 1 +
constantly.egg-info/pbr.json | 1 +
constantly.egg-info/top_level.txt | 1 +
constantly/__init__.py | 24 +
constantly/_constants.py | 500 +++++++++
constantly/_version.py | 21 +
setup.cfg | 16 +
setup.py | 43 +
versioneer.py | 1699 ++++++++++++++++++++++++++++++
16 files changed, 2443 insertions(+)
diff --git a/CREDITS b/CREDITS
new file mode 100644
index 0000000..c5a0623
--- /dev/null
+++ b/CREDITS
@@ -0,0 +1,6 @@
+Amber Hawkie Brown
+Glyph Lefkowitz
+Jean-Paul Calderone
+Richard Wall
+Wilfredo Sánchez
+
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..2684131
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+Copyright (c) 2011-2015 Twisted Matrix Laboratories &
+Individual Contributors (see CREDITS)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 0000000..f0c477e
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1,5 @@
+include versioneer.py
+include constantly/_version.py
+include README.rst
+include LICENSE
+include CREDITS
diff --git a/PKG-INFO b/PKG-INFO
new file mode 100644
index 0000000..24171c1
--- /dev/null
+++ b/PKG-INFO
@@ -0,0 +1,37 @@
+Metadata-Version: 1.1
+Name: constantly
+Version: 15.1.0
+Summary: Symbolic constants in Python
+Home-page: https://github.com/twisted/constantly
+Author: Twisted Matrix Labs Developers
+Author-email: UNKNOWN
+License: MIT
+Description: Constantly
+ ==========
+
+ A library that provides symbolic constant support.
+ It includes collections and constants with text, numeric, and bit flag values.
+ Originally ``twisted.python.constants`` from the `Twisted <https://twistedmatrix.com/>`_ project.
+
+
+ Tests
+ -----
+
+ To run tests::
+
+ $ tox
+
+ This will run tests on Python 2.7, 3.3, 3.4, and PyPy, as well as doing coverage and pyflakes checks.
+
+Keywords: constants,enum,twisted
+Platform: UNKNOWN
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
diff --git a/README.rst b/README.rst
new file mode 100644
index 0000000..123348a
--- /dev/null
+++ b/README.rst
@@ -0,0 +1,16 @@
+Constantly
+==========
+
+A library that provides symbolic constant support.
+It includes collections and constants with text, numeric, and bit flag values.
+Originally ``twisted.python.constants`` from the `Twisted <https://twistedmatrix.com/>`_ project.
+
+
+Tests
+-----
+
+To run tests::
+
+ $ tox
+
+This will run tests on Python 2.7, 3.3, 3.4, and PyPy, as well as doing coverage and pyflakes checks.
diff --git a/constantly.egg-info/PKG-INFO b/constantly.egg-info/PKG-INFO
new file mode 100644
index 0000000..24171c1
--- /dev/null
+++ b/constantly.egg-info/PKG-INFO
@@ -0,0 +1,37 @@
+Metadata-Version: 1.1
+Name: constantly
+Version: 15.1.0
+Summary: Symbolic constants in Python
+Home-page: https://github.com/twisted/constantly
+Author: Twisted Matrix Labs Developers
+Author-email: UNKNOWN
+License: MIT
+Description: Constantly
+ ==========
+
+ A library that provides symbolic constant support.
+ It includes collections and constants with text, numeric, and bit flag values.
+ Originally ``twisted.python.constants`` from the `Twisted <https://twistedmatrix.com/>`_ project.
+
+
+ Tests
+ -----
+
+ To run tests::
+
+ $ tox
+
+ This will run tests on Python 2.7, 3.3, 3.4, and PyPy, as well as doing coverage and pyflakes checks.
+
+Keywords: constants,enum,twisted
+Platform: UNKNOWN
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
diff --git a/constantly.egg-info/SOURCES.txt b/constantly.egg-info/SOURCES.txt
new file mode 100644
index 0000000..d800623
--- /dev/null
+++ b/constantly.egg-info/SOURCES.txt
@@ -0,0 +1,15 @@
+CREDITS
+LICENSE
+MANIFEST.in
+README.rst
+setup.cfg
+setup.py
+versioneer.py
+constantly/__init__.py
+constantly/_constants.py
+constantly/_version.py
+constantly.egg-info/PKG-INFO
+constantly.egg-info/SOURCES.txt
+constantly.egg-info/dependency_links.txt
+constantly.egg-info/pbr.json
+constantly.egg-info/top_level.txt
\ No newline at end of file
diff --git a/constantly.egg-info/dependency_links.txt b/constantly.egg-info/dependency_links.txt
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/constantly.egg-info/dependency_links.txt
@@ -0,0 +1 @@
+
diff --git a/constantly.egg-info/pbr.json b/constantly.egg-info/pbr.json
new file mode 100644
index 0000000..37fc140
--- /dev/null
+++ b/constantly.egg-info/pbr.json
@@ -0,0 +1 @@
+{"is_release": false, "git_version": "c8375a7"}
\ No newline at end of file
diff --git a/constantly.egg-info/top_level.txt b/constantly.egg-info/top_level.txt
new file mode 100644
index 0000000..6057189
--- /dev/null
+++ b/constantly.egg-info/top_level.txt
@@ -0,0 +1 @@
+constantly
diff --git a/constantly/__init__.py b/constantly/__init__.py
new file mode 100644
index 0000000..d9e6ec7
--- /dev/null
+++ b/constantly/__init__.py
@@ -0,0 +1,24 @@
+# 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',
+]
diff --git a/constantly/_constants.py b/constantly/_constants.py
new file mode 100644
index 0000000..44087b6
--- /dev/null
+++ b/constantly/_constants.py
@@ -0,0 +1,500 @@
+# -*- 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
diff --git a/constantly/_version.py b/constantly/_version.py
new file mode 100644
index 0000000..2b1beb5
--- /dev/null
+++ b/constantly/_version.py
@@ -0,0 +1,21 @@
+
+# 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)
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 0000000..0351cc6
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,16 @@
+[bdist_wheel]
+universal = 1
+
+[versioneer]
+vcs = git
+style = pep440
+versionfile_source = constantly/_version.py
+versionfile_build = constantly/_version.py
+tag_prefix =
+parentdir_prefix = constantly-
+
+[egg_info]
+tag_build =
+tag_date = 0
+tag_svn_revision = 0
+
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..6f66190
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,43 @@
+# Copyright (c) Twisted Matrix Laboratories.
+# See LICENSE for details.
+
+import codecs
+import os
+import versioneer
+
+from setuptools import setup
+
+def read(*parts):
+ """
+ Build an absolute path from C{parts} and and return the contents of the
+ resulting file. Assume UTF-8 encoding.
+ """
+ here = os.path.abspath(os.path.dirname(__file__))
+ with codecs.open(os.path.join(here, *parts), 'r', 'utf-8') as f:
+ return f.read()
+
+if __name__ == "__main__":
+ setup(
+ classifiers=[
+ 'Intended Audience :: Developers',
+ 'License :: OSI Approved :: MIT License',
+ 'Operating System :: OS Independent',
+ 'Programming Language :: Python',
+ 'Programming Language :: Python :: 2.7',
+ 'Programming Language :: Python :: 3.3',
+ 'Programming Language :: Python :: 3.4',
+ 'Programming Language :: Python :: Implementation :: CPython',
+ 'Programming Language :: Python :: Implementation :: PyPy',
+ 'Topic :: Software Development :: Libraries :: Python Modules'
+ ],
+ description="Symbolic constants in Python",
+ long_description=read('README.rst'),
+ keywords="constants,enum,twisted",
+ license="MIT",
+ name="constantly",
+ packages=["constantly"],
+ url="https://github.com/twisted/constantly",
+ maintainer='Twisted Matrix Labs Developers',
+ version=versioneer.get_version(),
+ cmdclass=versioneer.get_cmdclass(),
+ )
diff --git a/versioneer.py b/versioneer.py
new file mode 100644
index 0000000..c010f63
--- /dev/null
+++ b/versioneer.py
@@ -0,0 +1,1699 @@
+
+# Version: 0.15
+
+"""
+The Versioneer
+==============
+
+* like a rocketeer, but for versions!
+* https://github.com/warner/python-versioneer
+* Brian Warner
+* License: Public Domain
+* Compatible With: python2.6, 2.7, 3.2, 3.3, 3.4, and pypy
+* [![Latest Version]
+(https://pypip.in/version/versioneer/badge.svg?style=flat)
+](https://pypi.python.org/pypi/versioneer/)
+* [![Build Status]
+(https://travis-ci.org/warner/python-versioneer.png?branch=master)
+](https://travis-ci.org/warner/python-versioneer)
+
+This is a tool for managing a recorded version number in distutils-based
+python projects. The goal is to remove the tedious and error-prone "update
+the embedded version string" step from your release process. Making a new
+release should be as easy as recording a new tag in your version-control
+system, and maybe making new tarballs.
+
+
+## Quick Install
+
+* `pip install versioneer` to somewhere to your $PATH
+* add a `[versioneer]` section to your setup.cfg (see below)
+* run `versioneer install` in your source tree, commit the results
+
+## Version Identifiers
+
+Source trees come from a variety of places:
+
+* a version-control system checkout (mostly used by developers)
+* a nightly tarball, produced by build automation
+* a snapshot tarball, produced by a web-based VCS browser, like github's
+ "tarball from tag" feature
+* a release tarball, produced by "setup.py sdist", distributed through PyPI
+
+Within each source tree, the version identifier (either a string or a number,
+this tool is format-agnostic) can come from a variety of places:
+
+* ask the VCS tool itself, e.g. "git describe" (for checkouts), which knows
+ about recent "tags" and an absolute revision-id
+* the name of the directory into which the tarball was unpacked
+* an expanded VCS keyword ($Id$, etc)
+* a `_version.py` created by some earlier build step
+
+For released software, the version identifier is closely related to a VCS
+tag. Some projects use tag names that include more than just the version
+string (e.g. "myproject-1.2" instead of just "1.2"), in which case the tool
+needs to strip the tag prefix to extract the version identifier. For
+unreleased software (between tags), the version identifier should provide
+enough information to help developers recreate the same tree, while also
+giving them an idea of roughly how old the tree is (after version 1.2, before
+version 1.3). Many VCS systems can report a description that captures this,
+for example `git describe --tags --dirty --always` reports things like
+"0.7-1-g574ab98-dirty" to indicate that the checkout is one revision past the
+0.7 tag, has a unique revision id of "574ab98", and is "dirty" (it has
+uncommitted changes.
+
+The version identifier is used for multiple purposes:
+
+* to allow the module to self-identify its version: `myproject.__version__`
+* to choose a name and prefix for a 'setup.py sdist' tarball
+
+## Theory of Operation
+
+Versioneer works by adding a special `_version.py` file into your source
+tree, where your `__init__.py` can import it. This `_version.py` knows how to
+dynamically ask the VCS tool for version information at import time.
+
+`_version.py` also contains `$Revision$` markers, and the installation
+process marks `_version.py` to have this marker rewritten with a tag name
+during the `git archive` command. As a result, generated tarballs will
+contain enough information to get the proper version.
+
+To allow `setup.py` to compute a version too, a `versioneer.py` is added to
+the top level of your source tree, next to `setup.py` and the `setup.cfg`
+that configures it. This overrides several distutils/setuptools commands to
+compute the version when invoked, and changes `setup.py build` and `setup.py
+sdist` to replace `_version.py` with a small static file that contains just
+the generated version data.
+
+## Installation
+
+First, decide on values for the following configuration variables:
+
+* `VCS`: the version control system you use. Currently accepts "git".
+
+* `style`: the style of version string to be produced. See "Styles" below for
+ details. Defaults to "pep440", which looks like
+ `TAG[+DISTANCE.gSHORTHASH[.dirty]]`.
+
+* `versionfile_source`:
+
+ A project-relative pathname into which the generated version strings should
+ be written. This is usually a `_version.py` next to your project's main
+ `__init__.py` file, so it can be imported at runtime. If your project uses
+ `src/myproject/__init__.py`, this should be `src/myproject/_version.py`.
+ This file should be checked in to your VCS as usual: the copy created below
+ by `setup.py setup_versioneer` will include code that parses expanded VCS
+ keywords in generated tarballs. The 'build' and 'sdist' commands will
+ replace it with a copy that has just the calculated version string.
+
+ This must be set even if your project does not have any modules (and will
+ therefore never import `_version.py`), since "setup.py sdist" -based trees
+ still need somewhere to record the pre-calculated version strings. Anywhere
+ in the source tree should do. If there is a `__init__.py` next to your
+ `_version.py`, the `setup.py setup_versioneer` command (described below)
+ will append some `__version__`-setting assignments, if they aren't already
+ present.
+
+* `versionfile_build`:
+
+ Like `versionfile_source`, but relative to the build directory instead of
+ the source directory. These will differ when your setup.py uses
+ 'package_dir='. If you have `package_dir={'myproject': 'src/myproject'}`,
+ then you will probably have `versionfile_build='myproject/_version.py'` and
+ `versionfile_source='src/myproject/_version.py'`.
+
+ If this is set to None, then `setup.py build` will not attempt to rewrite
+ any `_version.py` in the built tree. If your project does not have any
+ libraries (e.g. if it only builds a script), then you should use
+ `versionfile_build = None` and override `distutils.command.build_scripts`
+ to explicitly insert a copy of `versioneer.get_version()` into your
+ generated script.
+
+* `tag_prefix`:
+
+ a string, like 'PROJECTNAME-', which appears at the start of all VCS tags.
... 1565 lines suppressed ...
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/python-modules/packages/constantly.git
More information about the Python-modules-commits
mailing list