Python version.get_git_version函数代码示例

def setupPackage():
    # setup package
    setup(
        name='obspy',
        version=get_git_version(),
        description=DOCSTRING[1],
        long_description="\n".join(DOCSTRING[3:]),
        url="http://www.obspy.org",
        author='The ObsPy Development Team',
        author_email='[email protected]',
        license='GNU Lesser General Public License, Version 3 (LGPLv3)',
        platforms='OS Independent',
        classifiers=[
            'Development Status :: 4 - Beta',
            'Environment :: Console',
            'Intended Audience :: Science/Research',
            'Intended Audience :: Developers',
            'License :: OSI Approved :: GNU Library or ' +
                'Lesser General Public License (LGPL)',
            'Operating System :: OS Independent',
            'Programming Language :: Python',
            'Topic :: Scientific/Engineering',
            'Topic :: Scientific/Engineering :: Physics'],
        keywords=KEYWORDS,
        packages=find_packages(),
        namespace_packages=[],
        zip_safe=False,
        install_requires=INSTALL_REQUIRES,
        download_url=("https://github.com/obspy/obspy/zipball/master"
            "#egg=obspy=dev"),  # this is needed for "easy_install obspy==dev"
        include_package_data=True,
        entry_points=ENTRY_POINTS,
        ext_package='obspy.lib',
        configuration=configuration)

def get_current_version(release):
    try:
        import version
        current_version = version.get_git_version(release=release)
        with open('ptracker/__init__.py', 'w') as init:
            init.write("VERSION = '{0}'\n".format(current_version))
        print("Wrote ptracker/__init__.py with version {0}".format(current_version))
        return current_version
    except ImportError:
        return ptracker.VERSION

def main():
    # Version of this software
    version = '0.9a2'
    
    parser = argparse.ArgumentParser()
    parser.add_argument('-H', '--host',
                        help='Address where this server listens.',
                        default='localhost')
    parser.add_argument('-P', '--port',
                        help='Port where this server listens.',
                        default='7000')
    parser.add_argument('-c', '--config',
                        help='Config file.',
                        default='ownDC.cfg')
    parser.add_argument('--version', action='version',
                        version='ownDC %s' % get_git_version())
    args = parser.parse_args()

    # Check arguments (IP, port)
    host = args.host
    
    configP = configparser.RawConfigParser()
    configP.read(args.config)

    verbo = configP.get('Service', 'verbosity')
    verboNum = getattr(logging, verbo.upper(), 30)
    
    logging.basicConfig(logLevel=verboNum)
    loclog = logging.getLogger('main')
    loclog.setLevel(verboNum)

    try:
        port = int(args.port)
    except:
        loclog.error('Error while interpreting port %s' % args.port)
        sys.exit(-1)

    # Create the object that will resolve and execute all the queries
    loclog.info('Creating a DataSelectQuery object. Wait...')
    ServerHandler.wi = DataSelectQuery('ownDC.log', './data/ownDC-routes.xml',
                                       configFile=args.config)
    loclog.info('Ready to answer queries!')
    
    Handler = ServerHandler
    httpd = socsrv.TCPServer((host, port), Handler)
    
    loclog.info("Virtual Datacentre at: http://%s:%s/fdsnws/dataselect/1/" %
                (host, port))
    httpd.serve_forever()

def setupPackage():
    # setup package
    setup(
        name="obspy",
        version=get_git_version(),
        description=DOCSTRING[1],
        long_description="\n".join(DOCSTRING[3:]),
        url="http://www.obspy.org",
        author="The ObsPy Development Team",
        author_email="[email protected]",
        license="GNU Lesser General Public License, Version 3 (LGPLv3)",
        platforms="OS Independent",
        classifiers=[
            "Development Status :: 4 - Beta",
            "Environment :: Console",
            "Intended Audience :: Science/Research",
            "Intended Audience :: Developers",
            "License :: OSI Approved :: GNU Library or " + "Lesser General Public License (LGPL)",
            "Operating System :: OS Independent",
            "Programming Language :: Python",
            "Programming Language :: Python :: 2",
            "Programming Language :: Python :: 2.6",
            "Programming Language :: Python :: 2.7",
            "Programming Language :: Python :: 3",
            "Programming Language :: Python :: 3.3",
            "Programming Language :: Python :: 3.4",
            "Topic :: Scientific/Engineering",
            "Topic :: Scientific/Engineering :: Physics",
        ],
        keywords=KEYWORDS,
        packages=find_packages(),
        namespace_packages=[],
        zip_safe=False,
        install_requires=INSTALL_REQUIRES,
        extras_require=EXTRAS_REQUIRE,
        features=add_features(),
        # this is needed for "easy_install obspy==dev"
        download_url=("https://github.com/obspy/obspy/zipball/master" "#egg=obspy=dev"),
        include_package_data=True,
        entry_points=ENTRY_POINTS,
        ext_package="obspy.lib",
        cmdclass={"build_man": Help2ManBuild, "install_man": Help2ManInstall},
        configuration=configuration,
    )

    def connect(self, data):
        """
        Connects to the server if both hostname and username is set.

        """
        if self.host is None:
            raise Warning(' '.join(['You must set the server\'s',
                                    'hostname and your name before',
                                    'connecting']))

        self.nick = data[2].split()[0]
        name = ' '.join(data[2].split()[1:])
        try:
            self.tcp.connect((self.host, int(self.port)))
        except socket.error as e:
            return self.denied([e.strerror])
        self.tcp.send(
            bytes('CONNECT: "{0}" "{1}" {2}\r\n'.format(self.nick,
                                                        name,
                                                        get_git_version()))
        )
        self.tcp.handle.start()

import os
import sys
import fnmatch
import subprocess

## prepare to run PyTest as a command
from distutils.core import Command

## explain this...
#from distribute_setup import use_setuptools
#use_setuptools()

from setuptools import setup, find_packages

from version import get_git_version
VERSION = get_git_version()
PROJECT = 'kba.scorer'
AUTHOR = 'Diffeo, Inc.'
AUTHOR_EMAIL = '[email protected]'
DESC = 'Tools for scoring output of systems built to compete in TREC KBA.'

def read_file(file_name):
    file_path = os.path.join(
        os.path.dirname(__file__),
        file_name
        )
    return open(file_path).read()

def recursive_glob(treeroot, pattern):
    results = []
    for base, dirs, files in os.walk(treeroot):

# possible, according to krischer
import sys
import os
import inspect
SETUP_DIRECTORY = os.path.dirname(os.path.abspath(inspect.getfile(
    inspect.currentframe())))

# Import the version string.
UTIL_PATH = os.path.join(SETUP_DIRECTORY, "nsl", "util")
sys.path.insert(0, UTIL_PATH)
from version import get_git_version  # @UnresolvedImport
sys.path.pop(0)

s_args = {
    'name': 'nsl.common',
    'version': get_git_version(),
    'description': 'NSL Common libraries and utilities for Python',
    'author': 'Nevada Seismological Lab',
    'url': 'https//github.com/NVSeismoLab',
    'packages': [
        'nsl',
        'nsl.common',
        'nsl.common.logging',
        'nsl.antelope',
        'nsl.antelope.base',
        'nsl.antelope.packets',
        'nsl.antelope.rows',
        'nsl.antelope.util',
        'nsl.converters', 
        'nsl.obspy',
        'nsl.obspy.patches',

    ('/usr/local/share/helpim/templates/forms', 'helpim/questionnaire/templates/forms'),
    ('/usr/local/share/helpim/fixtures', 'helpim/fixtures'),
    ('/usr/local/share/helpim/doc/debian/example', 'helpim/doc/debian/example'),
    ]

static_files = []
for target, include_dir in include_dirs:
    for root, dirs, files in walk(include_dir):
        static_files.append((
          join(target, root[len(include_dir)+1:]),
          [join(root, f) for f in files]
        ))

setup(
    name=name,
    version=get_git_version().lstrip('v'),
    url='http://www.python.org/pypi/'+name,
    license='AGPL',
    description='A chat-system for online psycho-social counselling',
    long_description=long_description,
    author='e-hulp.nl HelpIM Team',
    author_email='[email protected]',
    packages=find_packages('.'),
    package_dir={'': '.'},
    install_requires=install_requires,
    zip_safe = False,
    namespace_packages=[],
    data_files=static_files,
    include_package_data = True,
    classifiers = [
      "Programming Language :: Python",

def main():
    ownDCver = '0.9a2'

    parser = argparse.ArgumentParser(description=\
        'Client to download waveforms from different datacentres via FDSN-WS')
    parser.add_argument('-c', '--config', help='Config file.',
                        default='ownDC.cfg')
    parser.add_argument('-p', '--post-file', default=None,
                        help='File with the streams and timewindows requested.')
    parser.add_argument('-o', '--output', default='request',
                        help='Filename (without extension) used to save the data and the logs.')
    parser.add_argument('-r', '--retries', type=int,
                        help='Number of times that data should be requested if there is no answer or if there is an error',
                        default=0)
    group = parser.add_mutually_exclusive_group()
    group.add_argument("-s", "--seconds", type=int,
                        help='Number of seconds between retries for the lines without data')
    group.add_argument("-m", "--minutes", type=int,
                        help='Number of minutes between retries for the lines without data')
    parser.add_argument('-v', '--verbosity', action="count", default=0,
                        help='Increase the verbosity level')
    parser.add_argument('--version', action='version', version='ownDC-cli %s ' % get_git_version())
    args = parser.parse_args()
    
    # Read the streams and timewindows to download
    if args.post_file is not None:
        fh = open(args.post_file, 'r')
    else:
        fh = sys.stdin

    lines = fh.read()
    summary = SummarizedRun()

    ds = DataSelectQuery(summary,
                         routesFile='data/ownDC-routes.xml',
                         configFile=args.config)

    outwav = open('%s.mseed' % args.output, 'wb')

    # Attempt number to download the waveforms
    attempt = 0

    while ((attempt <= args.retries) and (len(lines.splitlines()) > 0)):
        print '\n\nAttempt Nr. %d of %d' % (attempt+1, args.retries+1)

        iterObj = ds.makeQueryPOST(lines)
        
        for chunk in iterObj:
            outwav.write(chunk)
            print '.',

        print

        lines = ''
        for k, v in summary.iteritems():

            # Print summary
            totBytes = sum([l[2] for l in v])
            status = ','.join([l[1] for l in v])

            print '[%s] %s %d bytes' % ('\033[92mOK\033[0m' if totBytes else \
                                        '\033[91m' + status + '\033[0m', k, totBytes)
            # Check the total amount of bytes received
            if totBytes <= 0:
                lines = '%s%s\n' % (lines, k)

        attempt += 1

        if args.minutes:
            print 'Waiting %d minutes to retry again...' % args.minutes
            sleep(args.minutes * 60)
        else:
            seconds = 2 if args.seconds is None else args.seconds
            
            print 'Waiting %d seconds to retry again...' % seconds
            sleep(seconds)

    outwav.close()
    
    # FIXME I should decide here a nice format for the output
    # and also if it should be to stdout, a file or a port
    with open('%s.log' % args.output, 'w') as outlog:
        for k, v in summary.iteritems():
            outlog.write('%s %s %d bytes\n' % (k, [le[1] for le in v], sum([le[2] for le in v])))

from version import get_git_version

__productname__ = 'alot'
__version__ = get_git_version()
__copyright__ = "Copyright (C) 2011 Patrick Totzke"
__author__ = "Patrick Totzke"
__author_email__ = "[email protected]"
__description__ = "Terminal MUA using notmuch mail"
__url__ = "https://github.com/pazz/alot"
__license__ = "Licensed under the GNU GPL v3+."

from setuptools.command.build_py import build_py

class build_py_with_sub_commands(build_py):

    def run(self):
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

        build_py.run(self)
    
build_py_with_sub_commands.sub_commands.append(('build_uml', None))


setup(
    name='gaphor',
    version=get_git_version(),
    url='http://gaphor.sourceforge.net',
    author='Arjan J. Molenaar',
    author_email='[email protected]',
    license='GNU General Public License',
    description='Gaphor is a UML modeling tool',
    long_description="""
Gaphor is a UML modeling tool written in Python.

It uses the GTK+ environment for user interaction.
""",
    classifiers = [
        'Development Status :: 5 - Production/Stable',
        'Environment :: X11 Applications :: GTK',
        'Intended Audience :: Developers',
        'Intended Audience :: End Users/Desktop',

import version

__version__ = version.get_git_version()

        if self.distribution.tests_require:
            cmd.extend(self.distribution.tests_require)
        errno = subprocess.call(cmd)
        if errno:
            raise SystemExit(errno)

        # reload sys.path for any new libraries installed
        import site
        site.main()
        print sys.path
        # use pytest to run tests
        pytest = __import__('pytest')
        exitcode = pytest.main(['--cov', 'pyaccumulo', '--cov-report', 'term', '-vvs', 'tests'])
        sys.exit(exitcode)

VERSION, HASH = version.get_git_version()

setup(
      name = 'pyaccumulo',
      version = VERSION,
      author = 'Jason Trost',
      author_email = 'jason.trost AT gmail.com',
      maintainer = 'Jason Trost',
      maintainer_email = 'jason.trost AT gmail.com',
      description = 'Python client library for Apache Accumulo',
      long_description = long_description,
      url = 'https://github.com/accumulo/pyaccumulo',
      keywords = 'accumulo client db distributed thrift',
      packages = ['pyaccumulo',
                  'pyaccumulo.iterators',
                  'pyaccumulo.proxy'

#!/usr/bin/env python

import os
from setuptools import setup, find_packages
import subprocess
import shlex
import version

reqs = os.path.join(os.path.abspath(os.path.dirname(__file__)),
                    'requirements.txt')
REQUIRES = filter(None, open(reqs).read().splitlines())

ver = version.get_git_version()

# Listing inflection module as requirements is not working in windows for some
# reason. So install it using pip install.

setup(
    name="robotframework-pageobjects",
    version=ver,
    description="Lets you use the page object pattern with Robot Framework and plain python", 
    author="National Center for Biotechnology Information",
    install_requires=REQUIRES,
    packages=find_packages(exclude=("tests",)),
    zip_safe=False
)

        c_files,
        include_dirs=include_dirs,
        libraries=libraries,
        library_dirs=library_dirs,
        define_macros=macros,
        extra_compile_args=compile_args,
        extra_link_args=link_args,
    )
]

install_requires = []
tests_require = []

setup(
    name="pylzma",
    version=get_git_version().decode("utf-8"),
    description=descr,
    author="Joachim Bauch",
    author_email="[email protected]",
    url="http://www.joachim-bauch.de/projects/pylzma/",
    download_url="http://pypi.python.org/pypi/pylzma/",
    license="LGPL",
    keywords="lzma compression",
    long_description=long_descr,
    classifiers=[
        "Development Status :: 5 - Production/Stable",
        "Programming Language :: Python",
        "Programming Language :: Python :: 3",
        "Topic :: Software Development :: Libraries :: Python Modules",
        "Intended Audience :: Developers",
        "License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)",