Python versioneer.get_version函数代码示例

def setup_versioneer():
    '''
    Generate (temporarily) versioneer.py file in project root directory
    :return:
    '''
    try:
        # assume versioneer.py was generated using "versioneer install" command
        import versioneer
        versioneer.get_version()
    except ImportError:
        # it looks versioneer.py is missing
        # lets assume that versioneer package is installed
        # and versioneer binary is present in $PATH
        import subprocess
        try:
            # call versioneer install to generate versioneer.py
            subprocess.check_output(["versioneer", "install"])
        except OSError:
            # it looks versioneer is missing from $PATH
            # probably versioneer is installed in some user directory

            # query pip for list of files in versioneer package
            output = pip_command_output(["show", "-f", "versioneer"])

            # now we parse the results
            main_path = [x[len("Location: "):] for x in output.split('\n')
                         if x.startswith("Location")][0]
            bin_path = [x[len("  "):] for x in output.split('\n')
                        if x.endswith("/versioneer")][0]

            # exe_path is absolute path to versioneer binary
            import os
            exe_path = os.path.join(main_path, bin_path)
            # call versioneer install to generate versioneer.py
            subprocess.check_output([exe_path, "install"])

def main(**extra_args):
    setup(name=info.NAME,
          maintainer=info.MAINTAINER,
          maintainer_email=info.MAINTAINER_EMAIL,
          description=info.DESCRIPTION,
          url=info.URL,
          download_url=info.DOWNLOAD_URL,
          license=info.LICENSE,
          classifiers=info.CLASSIFIERS,
          author=info.AUTHOR,
          author_email=info.AUTHOR_EMAIL,
          platforms=info.PLATFORMS,
          version=versioneer.get_version(),
          requires=info.REQUIRES,
          provides=info.PROVIDES,
          packages     = ['regreg',
                          'regreg.tests',
                          'regreg.affine',
                          'regreg.affine.tests',
                          'regreg.atoms',
                          'regreg.atoms.tests',
                          'regreg.problems',
                          'regreg.problems.tests',
                          'regreg.smooth',
                          'regreg.smooth.tests',
                         ],
          ext_modules = EXTS,
          package_data = {},
          data_files=[],
          scripts= [],
          long_description = open('README.rst', 'rt').read(),
          cmdclass = cmdclass,
          **extra_args
         )

def run_setup():
    setup(
        name='copulae',
        author=AUTHOR,
        author_email=EMAIL,
        maintainer=AUTHOR,
        maintainer_email=EMAIL,
        packages=find_packages(include=['copulae', 'copulae.*']),
        license="MIT",
        version=versioneer.get_version(),
        description='Python copulae library for dependency modelling',
        long_description=long_description,
        long_description_content_type='text/markdown',
        url='https://github.com/DanielBok/copulae',
        keywords=['copula', 'copulae', 'dependency modelling', 'dependence structures', 'archimdean', 'elliptical',
                  'finance'],
        classifiers=[
            'Development Status :: 3 - Alpha',
            'Intended Audience :: End Users/Desktop',
            'Intended Audience :: Financial and Insurance Industry',
            'Programming Language :: Python :: 3.6',
            'Programming Language :: Python :: 3.7',
            'License :: OSI Approved :: MIT',
            'Operating System :: MacOS :: MacOS X',
            'Operating System :: Microsoft :: Windows',
            'Operating System :: POSIX',
            'Programming Language :: Python',
            'Topic :: Scientific/Engineering',
        ],
        install_requires=requirements,
        setup_requires=setup_requirements,
        include_package_data=True,
        python_requires='>=3.6',
        zip_safe=False,
    )

def do_setup():
    setup(name=NAME,
          version=versioneer.get_version(),
          description=DESCRIPTION,
          long_description=LONG_DESCRIPTION,
          classifiers=CLASSIFIERS,
          author=AUTHOR,
          author_email=AUTHOR_EMAIL,
          url=URL,
          license=LICENSE,
          platforms=PLATFORMS,
          packages=find_packages(),
          cmdclass=versioneer.get_cmdclass(),
          install_requires=['numpy>=1.9.1', 'scipy>=0.14', 'six>=1.9.0'],
          # pygments is a dependency for Sphinx code highlight
          extras_require={
              'test': ['nose>=1.3.0', 'parameterized', 'flake8<3'],
              'doc': ['Sphinx>=0.5.1', 'pygments']
          },
          package_data={
              '': ['*.txt', '*.rst', '*.cu', '*.cuh', '*.c', '*.sh', '*.pkl',
                   '*.h', '*.cpp', 'ChangeLog', 'c_code/*'],
              'theano.misc': ['*.sh'],
              'theano.d3viz': ['html/*', 'css/*', 'js/*']
          },
          entry_points={
              'console_scripts': ['theano-cache = bin.theano_cache:main',
                                  'theano-nose = bin.theano_nose:main']
          },
          keywords=' '.join([
              'theano', 'math', 'numerical', 'symbolic', 'blas',
              'numpy', 'gpu', 'autodiff', 'differentiation'
          ]),
    )

def main():

    setup(name='datarail',
          version=versioneer.get_version(),
          description='DataRail',
          long_description=(
              'DataRail is a framework for managing, transforming,'
              ' visualizing, and processing scientific data, in particular'
              ' that generated by high-dimensional multi-factorial'
              ' experimental designs.'
          ),
          author='Marc Hafner',
          author_email='[email protected]',
          url='http://github.com/sorgerlab/datarail',
          packages=find_packages(),
          install_requires=['numpy', 'pandas', 'xarray'],
          cmdclass=versioneer.get_cmdclass(),
          keywords=['systems', 'biology', 'data', 'array', 'matrix'],
          classifiers=[
            'Development Status :: 3 - Alpha',
            'Environment :: Console',
            'Intended Audience :: Science/Research',
            'License :: OSI Approved :: BSD License',
            'Operating System :: OS Independent',
            'Programming Language :: Python :: 2',
            'Topic :: Scientific/Engineering :: Bio-Informatics',
            'Topic :: Scientific/Engineering :: Chemistry',
            'Topic :: Scientific/Engineering :: Mathematics',
            'Topic :: Scientific/Engineering :: Visualization',
            ],
          )

 def run(self):
     with open('python-flocker.spec.in', 'r') as source:
         spec = source.read()
     version = "%%global flocker_version %s\n" % (versioneer.get_version(),)
     with open('python-flocker.spec', 'w') as destination:
         destination.write(version)
         destination.write(spec)

def params():
    name = "netconnectd"
    version = versioneer.get_version()
    description = DESCRIPTION
    long_description = LONG_DESCRIPTION
    author = "Gina Haeussge"
    author_email = "[email protected]"
    url = "http://github.com/foosel/netconnectd"
    license = "AGPLV3"
    cmdclass = get_cmdclass()

    packages = ["netconnectd"]
    zip_safe = False

    dependency_links = [
        "https://github.com/foosel/wifi/tarball/master#egg=wifi-1.0.1"
    ]
    install_requires = [
        "wifi==1.0.1",
        "PyYaml",
        "netaddr"
    ]

    entry_points = {
        "console_scripts": {
            "netconnectd = netconnectd:server",
            "netconnectcli = netconnectd:client"
        }
    }

    return locals()

def process_setup():
    """
    Setup function
    """
    if sys.version_info < (3,0):
        sys.exit("build-utilities only supports python3. Please run setup.py with python3.")
       
    cmds = versioneer.get_cmdclass()
    cmds["install"] = InstallCommand
    setup(
        name="build-utilities",
        version=versioneer.get_version(),
        cmdclass=cmds,
        packages=find_packages("src"),
        package_dir ={'':'src'},
        install_requires=['GitPython>=2.0', 'progressbar2>=2.0.0'],
        author="Alexandre ACEBEDO",
        author_email="Alexandre ACEBEDO",
        description="Build utilities for python and go projects.",
        license="LGPLv3",
        keywords="build go python",
        url="http://github.com/aacebedo/build-utilities",
        entry_points={'console_scripts':
                      ['build-utilities = buildutilities.__main__:BuildUtilities.main']}
    )

def setup_package():
    needs_sphinx = {'build_sphinx', 'upload_docs'}.intersection(sys.argv)
    sphinx = ['sphinx'] if needs_sphinx else []
    setup(setup_requires=['six', 'pyscaffold>=2.5a0,<2.6a0'] + sphinx,
          version=versioneer.get_version(),
          cmdclass=versioneer.get_cmdclass(),
          use_pyscaffold=True)

def run_setup():
    setup(
        name="enversion",
        version=versioneer.get_version(),
        cmdclass=versioneer.get_cmdclass(),
        license="Apache",
        description="Enterprise Subversion Framework",
        author="Trent Nelson",
        author_email="[email protected]",
        url="http://www.enversion.org/",
        keywords="subversion,svn,scm,pysvn",
        packages=find_packages("lib"),
        package_dir={"": "lib"},
        entry_points={"console_scripts": ["evnadmin = evn.admin.cli:main"]},
        classifiers=[
            "Environment :: Console",
            "License :: OSI Approved :: Apache Software License",
            "Development Status :: 5 - Production/Stable",
            "Operating System :: POSIX",
            "Operating System :: MacOS :: MacOS X",
            "Operating System :: Microsoft :: Windows",
            "Intended Audience :: Developers",
            "Intended Audience :: System Administrators",
            "Intended Audience :: Information Technology",
            "Programming Language :: Python",
            "Programming Language :: Unix Shell",
            "Topic :: Software Development :: Quality Assurance",
            "Topic :: Software Development :: Version Control",
        ],
    )

def run_setup():
    setup(
        name='tpn',
        version=versioneer.get_version(),
        cmdclass=versioneer.get_cmdclass(),
        license='MIT',
        description="Trent's Dev Tools",
        author='Trent Nelson',
        author_email='[email protected]',
        url='http://github.com/tpn',
        packages=find_packages('lib'),
        package_dir={'': 'lib'},
        entry_points={
            'console_scripts': [
                'tpn = tpn.cli:main',
            ],
        },
        classifiers=[
            'Environment :: Console',
            'License :: OSI Approved :: MIT',
            'Development Status :: 5 - Production/Stable',
            'Operating System :: Microsoft :: Windows',
            'Intended Audience :: Developers',
            'Intended Audience :: System Administrators',
            'Intended Audience :: Information Technology',
            'Programming Language :: Python',
            'Programming Language :: Unix Shell',
        ],
    )

def setup_package():

    _setup(
        name='pymor',
        version=versioneer.get_version(),
        author='pyMOR developers',
        author_email='[email protected]',
        maintainer='Rene Milk',
        maintainer_email='[email protected]',
        package_dir={'': 'src'},
        packages=find_packages('src'),
        include_package_data=True,
        scripts=['src/pymor-demo', 'dependencies.py'],
        url='http://pymor.org',
        description=' ',
        python_requires='>=3.6',
        long_description=open('README.md').read(),
        long_description_content_type='text/markdown',
        setup_requires=setup_requires,
        tests_require=tests_require,
        install_requires=install_requires,
        extras_require = dependencies.extras(),
        classifiers=['Development Status :: 4 - Beta',
                     'License :: OSI Approved :: BSD License',
                     'Programming Language :: Python :: 3.6',
                     'Programming Language :: Python :: 3.7',
                     'Intended Audience :: Science/Research',
                     'Topic :: Scientific/Engineering :: Mathematics'],
        license='LICENSE.txt',
        zip_safe=False,
        cmdclass=cmdclass,
    )

def setup_package():
    # Assemble additional setup commands
    cmdclass = versioneer.get_cmdclass()
    cmdclass['docs'] = sphinx_builder()
    cmdclass['doctest'] = sphinx_builder()
    cmdclass['test'] = PyTest

    # Some helper variables
    version = versioneer.get_version()
    docs_path = os.path.join(__location__, "doc")
    docs_build_path = os.path.join(docs_path, "_build")
    install_reqs = get_install_requirements("requirements.txt")

    command_options = {
        'docs': {'project': ('setup.py', MAIN_PACKAGE),
                 'version': ('setup.py', version.split('-', 1)[0]),
                 'release': ('setup.py', version),
                 'build_dir': ('setup.py', docs_build_path),
                 'config_dir': ('setup.py', docs_path),
                 'source_dir': ('setup.py', docs_path)},
        'doctest': {'project': ('setup.py', MAIN_PACKAGE),
                    'version': ('setup.py', version.split('-', 1)[0]),
                    'release': ('setup.py', version),
                    'build_dir': ('setup.py', docs_build_path),
                    'config_dir': ('setup.py', docs_path),
                    'source_dir': ('setup.py', docs_path),
                    'builder': ('setup.py', 'doctest')},
        'test': {'test_suite': ('setup.py', 'test'),
                 'cov': ('setup.py', 'puq')}}
    if JUNIT_XML:
        command_options['test']['junitxml'] = ('setup.py', 'junit.xml')
    if COVERAGE_XML:
        command_options['test']['cov_xml'] = ('setup.py', True)
    if COVERAGE_HTML:
        command_options['test']['cov_html'] = ('setup.py', True)

    from numpy.distutils.misc_util import get_numpy_include_dirs
    incdirs = get_numpy_include_dirs()

    setup(name=MAIN_PACKAGE,
          version=version,
          url=URL,
          description=DESCRIPTION,
          author=AUTHOR,
          author_email=EMAIL,
          license=LICENSE,
          long_description=read('README.rst'),
          classifiers=CLASSIFIERS,
          test_suite='tests',
          packages=setuptools.find_packages(exclude=['tests', 'tests.*']),
          install_requires=install_reqs,
          setup_requires=['six'],
          cmdclass=cmdclass,
          tests_require=['pytest-cov', 'pytest'],
          command_options=command_options,
          entry_points={'console_scripts': CONSOLE_SCRIPTS},
          zip_safe=False,
          package_data={'puq': ['spgrid_cache.hdf5']},
          )

def params():
    name = "OctoPrint"
    version = versioneer.get_version()
    cmdclass = get_cmdclass()

    description = "A responsive web interface for 3D printers"
    long_description = open("README.md").read()
    classifiers = [
        "Development Status :: 4 - Beta",
        "Environment :: Web Environment",
        "Framework :: Flask",
        "Intended Audience :: Education",
        "Intended Audience :: End Users/Desktop",
        "Intended Audience :: Manufacturing",
        "Intended Audience :: Science/Research",
        "License :: OSI Approved :: GNU Affero General Public License v3",
        "Natural Language :: English",
        "Operating System :: OS Independent",
        "Programming Language :: Python :: 2.7",
        "Programming Language :: JavaScript",
        "Topic :: Internet :: WWW/HTTP",
        "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
        "Topic :: Internet :: WWW/HTTP :: WSGI",
        "Topic :: Printing",
        "Topic :: System :: Networking :: Monitoring"
    ]
    author = "Gina Häußge"
    author_email = "[email protected]"
    url = "http://octoprint.org"
    license = "AGPLv3"

    packages = find_packages(where="src")
    package_dir = {
        "": "src"
    }
    package_data = {
        "octoprint": octoprint_setuptools.package_data_dirs('src/octoprint',
                                                            ['static', 'templates', 'plugins', 'translations'])
    }

    include_package_data = True
    zip_safe = False
    install_requires = INSTALL_REQUIRES
    extras_require = EXTRA_REQUIRES
    dependency_links = DEPENDENCY_LINKS

    if os.environ.get('READTHEDOCS', None) == 'True':
        # we can't tell read the docs to please perform a pip install -e .[develop], so we help
        # it a bit here by explicitly adding the development dependencies, which include our
        # documentation dependencies
        install_requires = install_requires + extras_require['develop']

    entry_points = {
        "console_scripts": [
            "umprint = octoprint:main"
        ]
    }

    return locals()

def get_version():
    ''' The version of Bokeh currently checked out

    Returns:
        str : the version string

    '''
    return versioneer.get_version()