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 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 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 get_cmdclass():
    cmdclass = versioneer.get_cmdclass()
    cmdclass.update({
        'install_extras': InstallExtrasCommand,
        'uninstall_extras': UninstallExtrasCommand
    })
    return cmdclass

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 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 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 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 setup_package():
    # Assemble additional setup commands
    cmdclass = versioneer.get_cmdclass()
    cmdclass['docs'] = sphinx_builder()
    cmdclass['doctest'] = sphinx_builder()
    cmdclass['test'] = PyTest
    cmdclass['cythonize'] = Cythonize
    cmdclass['build_ext'] = NumpyBuildExt

    # Some helper variables
    version = versioneer.get_version()
    docs_path = os.path.join(__location__, "docs")
    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', 'tests'),
                 'cov': ('setup.py', 'pytesmo')}}
    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)

    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.*']),
          ext_modules=ext_modules,
          package_data={'pytesmo': [os.path.join('colormaps', '*.cmap')],
                        },
          install_requires=install_reqs,
          setup_requires=['six'],
          cmdclass=cmdclass,
          tests_require=['pytest-cov', 'pytest'],
          command_options=command_options,
          entry_points={'console_scripts': CONSOLE_SCRIPTS})

def get_cmdclass():
    """
    Get setuptools command class
    :return:
    """
    setup_versioneer()
    clean_cache()
    import versioneer
    return versioneer.get_cmdclass()

def get_cmdclass():
	cmdclass = versioneer.get_cmdclass()
	cmdclass.update({
		'clean': CleanCommand,
		'babel_new': NewTranslation,
		'babel_extract': ExtractTranslation,
		'babel_refresh': RefreshTranslation,
		'babel_compile': CompileTranslation
	})
	return cmdclass

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

    docs_path = os.path.join(__location__, 'docs')
    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', 'tests'), 'cov': ('setup.py', MAIN_PACKAGE)}}
    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

    setup(
        name=NAME,
        version=VERSION,
        url=URL,
        description=DESCRIPTION,
        author=AUTHOR,
        author_email=EMAIL,
        license=LICENSE,
        keywords='aws account vpc',
        long_description=read('README.rst'),
        classifiers=CLASSIFIERS,
        test_suite='tests',
        packages=setuptools.find_packages(exclude=['tests', 'tests.*']),
        install_requires=install_reqs,
        setup_requires=['six', 'flake8'],
        cmdclass=cmdclass,
        tests_require=['pytest-cov', 'pytest'],
        command_options=command_options,
        entry_points={'console_scripts': CONSOLE_SCRIPTS},
    )

def _setup(longdescription):
    setup(name=PKG,
          version=versioneer.get_version(),
          description='trigram model with back-off method',
          long_description=longdescription,
          author='L. Amber Wilcox-O\'Hearn',
          author_email='[email protected]',
          packages=['BackOffTrigramModel'],
          package_dir = {'': os.path.join('src', 'Python')},
          classifiers=trove_classifiers,
          cmdclass=versioneer.get_cmdclass(),
          )

def get_cmdclass():
    cmdclass = versioneer.get_cmdclass()
    cmdclass.update(
        {
            "clean": CleanCommand,
            "babel_new": NewTranslation,
            "babel_extract": ExtractTranslation,
            "babel_refresh": RefreshTranslation,
            "babel_compile": CompileTranslation,
        }
    )
    return cmdclass

def get_cmdclass():
	cmdclass = versioneer.get_cmdclass()

	# add clean command
	cmdclass.update(dict(clean=octoprint_setuptools.CleanCommand.for_options(source_folder="src", eggs=["OctoPrint*.egg-info"])))

	# add translation commands
	translation_dir = "translations"
	pot_file = os.path.join(translation_dir, "messages.pot")
	bundled_dir = os.path.join("src", "octoprint", "translations")
	cmdclass.update(octoprint_setuptools.get_babel_commandclasses(pot_file=pot_file, output_dir=translation_dir, pack_name_prefix="OctoPrint-i18n-", pack_path_prefix="", bundled_dir=bundled_dir))

	return cmdclass

def get_cmdclass():
    """Get our cmdclass dictionary for use in setuptool.setup().

    This must be done outside the call to setuptools.setup() because we need
    to add our own classes to the cmdclass dictionary, and then update that
    dictionary with the one returned from versioneer.get_cmdclass().
    """
    cmdclass = {'test': runTests}
    try:
        cmdclass.update(versioneer.get_cmdclass())
    except NameError:
        pass
    return cmdclass

def get_cmdclass():
    """Get our cmdclass dictionary for use in setuptool.setup().

    This must be done outside the call to setuptools.setup() because we need
    to add our own classes to the cmdclass dictionary, and then update that
    dictionary with the one returned from versioneer.get_cmdclass().
    """
    cmdclass = {'test': Trial,
                'compile_catalog': compile_catalog,
                'extract_messages': extract_messages,
                'init_catalog': init_catalog,
                'update_catalog': update_catalog}
    cmdclass.update(versioneer.get_cmdclass())
    return cmdclass

def setup_package():
    # Assemble additional setup commands
    cmdclass = versioneer.get_cmdclass()
    cmdclass['test'] = NoseTestCommand

    setup(
        name='SALib',
        packages=find_packages(exclude=["*tests*"]),
        author="Jon Herman and Will Usher",
        author_email="[email protected]",
        license=open('LICENSE.md').read(),
        tests_require=['nose'],
        install_requires=[
            "numpy>=1.9.0",
            "scipy",
            "matplotlib>=1.4.3",
        ],
          
        extras_require = {
                          "gurobipy": ["gurobipy",]
                          },
        
        # Two arguments required by Versioneer
        version = versioneer.get_version(),
        cmdclass=cmdclass,
        url="https://github.com/SALib/SALib",
        long_description=open('README.md').read(),
        description=(
            'Tools for sensitivity analysis. Contains Sobol, Morris, and FAST methods.'),
        # entry_points = {
        #     'console_scripts': [
        #         'salib = SALib.bin.salib:main',
        #     ]
        # },
        classifiers=[
            # 'Development Status :: 5 - Production/Stable',
            'Intended Audience :: End Users/Desktop',
            'Intended Audience :: Developers',
            'Intended Audience :: Science/Research',
            # 'License :: OSI Approved :: BSD License',
            'Operating System :: MacOS :: MacOS X',
            'Operating System :: Microsoft :: Windows',
            'Operating System :: POSIX',
            'Programming Language :: Python',
            # 'Programming Language :: Python :: 2.7',
            # 'Programming Language :: Python :: 2 :: Only',
            'Topic :: Scientific/Engineering :: Mathematics',
        ],)

def params():
	# Our metadata, as defined above
	name = plugin_name
	version = plugin_version
	cmdclass = versioneer.get_cmdclass()
	description = plugin_description
	author = plugin_author
	author_email = plugin_author_email
	url = plugin_url
	license = plugin_license

	# we only have our plugin package to install
	packages = [plugin_package]

	# we might have additional data files in sub folders that need to be installed too
	package_data = {plugin_package: package_data_dirs(plugin_package, ['static', 'templates', 'translations'] + plugin_additional_data)}
	include_package_data = True

	# If you have any package data that needs to be accessible on the file system, such as templates or static assets
	# this plugin is not zip_safe.
	zip_safe = False

	# Read the requirements from our requirements.txt file
	install_requires = requirements("requirements.txt")

	# Hook the plugin into the "octoprint.plugin" entry point, mapping the plugin_identifier to the plugin_package.
	# That way OctoPrint will be able to find the plugin and load it.
	entry_points = {
		"octoprint.plugin": ["%s = %s" % (plugin_identifier, plugin_package)]
	}

	ext_modules = [
		setuptools.Extension('gpx',
		sources = [
			'GPX/src/pymodule/gpxmodule.c',
			'GPX/src/shared/config.c',
			'GPX/src/shared/opt.c',
			'GPX/src/gpx/vector.c',
			'GPX/src/gpx/gpx.c',
			'GPX/src/gpx/gpx-main.c',
			],
		extra_compile_args = ['-DGPX_VERSION="\\"OctoPrint\\""', '-DSERIAL_SUPPORT', '-fvisibility=hidden', '-IGPX/src/shared', '-IGPX/src/gpx'],
		extra_link_args = ['-fvisibility=hidden'])
		]

	return locals()

def main():
    setupkw = dict(
            name='PyGBe',
            description='A boundary element method code that does molecular electrostatics calculations with a continuum approach',
            platforms='Linux',
            install_requires = ['numpy > 1.8',],
            license='MIT',
            version=versioneer.get_version(),
            cmdclass=versioneer.get_cmdclass(cmdclass={'build': CustomBuild, 'install': CustomInstall}),
            url='https://github.com/barbagroup/pygbe',
            classifiers=['Programming Language :: Python :: 3'],
            packages = find_packages(),
            #tell setuptools to use the custom build and install classes
            #create an entrance point that points to pygbe.main.main
            entry_points={'console_scripts': ['pygbe = pygbe.main:main',
                                              'pygbe-lspr = pygbe.lspr:main']},
            #SWIG modules with all compilation options
            ext_modules = [
                Extension("_multipole",
                          sources=["pygbe/tree/multipole.i", "pygbe/tree/multipole.cpp"],
                          swig_opts=['-c++','-py3'],
                          include_dirs=[numpy.get_include()],
                          extra_compile_args=['-fPIC', '-O3', '-funroll-loops', '-msse3', '-fopenmp'],
                ),
                Extension("_direct",
                          sources=["pygbe/tree/direct.i", "pygbe/tree/direct.cpp"],
                          swig_opts=['-c++','-py3'],
                          include_dirs=[numpy.get_include()],
                          extra_compile_args=['-fPIC', '-O3', '-funroll-loops', '-msse3', '-fopenmp'],
                ),
                Extension("_calculateMultipoles",
                          sources=["pygbe/tree/calculateMultipoles.i", "pygbe/tree/calculateMultipoles.cpp"],
                          swig_opts=['-c++','-py3'],
                          include_dirs=[numpy.get_include()],
                          extra_compile_args=['-fPIC', '-O3', '-funroll-loops', '-msse3', '-fopenmp'],
                ),
                Extension("_semi_analyticalwrap",
                          sources=["pygbe/util/semi_analyticalwrap.i", "pygbe/util/semi_analyticalwrap.cpp"],
                          swig_opts=['-c++','-py3'],
                          include_dirs=[numpy.get_include()],
                          extra_compile_args=['-fPIC', '-O3', '-funroll-loops', '-msse3', '-fopenmp'],
                ),
                ],
            )
    setup(**setupkw)